diff --git a/CHANGELOG.md b/CHANGELOG.md index 4d8bb3757..b0a99a4a8 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,8 @@ +# 3.0.1 + +### Bug Fixes: +Fixed: Added the locking mechanism to prevent multiple asynchronous operation from having concurrent access to Overlay (Orion processor's in-memory cache layer), which otherwise could lead to one asynchronous operation overriding the changes made (to the cache) by the other asynchronous operation. + # 3.0.0 This is a major release that will contains several breaking changes due to the introduction of the user account feature. Throught this release changelog the term diff --git a/assets/patches/@joystream+metadata-protobuf+2.8.1.patch b/assets/patches/@joystream+metadata-protobuf+2.8.1.patch new file mode 100644 index 000000000..ea6e0b6ca --- /dev/null +++ b/assets/patches/@joystream+metadata-protobuf+2.8.1.patch @@ -0,0 +1,622854 @@ +diff --git a/node_modules/@joystream/metadata-protobuf/.eslintignore b/node_modules/@joystream/metadata-protobuf/.eslintignore +new file mode 100644 +index 0000000..d0049b1 +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/.eslintignore +@@ -0,0 +1,4 @@ ++lib/ ++proto/ ++compiled/ ++.eslintrc.js +diff --git a/node_modules/@joystream/metadata-protobuf/.eslintrc.js b/node_modules/@joystream/metadata-protobuf/.eslintrc.js +new file mode 100644 +index 0000000..d8ea276 +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/.eslintrc.js +@@ -0,0 +1,16 @@ ++module.exports = { ++ env: { ++ mocha: true, ++ }, ++ parserOptions: { ++ project: './tsconfig.json' ++ }, ++ extends: [ ++ '@joystream/eslint-config' ++ ], ++ rules: { ++ 'no-unused-vars': 'off', // Required by the typescript rule below ++ '@typescript-eslint/no-unused-vars': ['error'], ++ '@typescript-eslint/no-floating-promises': 'error', ++ }, ++} +diff --git a/node_modules/@joystream/metadata-protobuf/.gitignore b/node_modules/@joystream/metadata-protobuf/.gitignore +new file mode 100644 +index 0000000..1789b65 +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/.gitignore +@@ -0,0 +1,4 @@ ++node_modules/ ++lib/ ++compiled/ ++src/json/*.json +diff --git a/node_modules/@joystream/metadata-protobuf/.prettierignore b/node_modules/@joystream/metadata-protobuf/.prettierignore +new file mode 100644 +index 0000000..79fafec +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/.prettierignore +@@ -0,0 +1,5 @@ ++lib/ ++doc/ ++proto/ ++compiled/ ++src/json/messages.json +\ No newline at end of file +diff --git a/node_modules/@joystream/metadata-protobuf/compiled/index.d.ts b/node_modules/@joystream/metadata-protobuf/compiled/index.d.ts +old mode 100755 +new mode 100644 +index c95539d..eabd4b9 +--- a/node_modules/@joystream/metadata-protobuf/compiled/index.d.ts ++++ b/node_modules/@joystream/metadata-protobuf/compiled/index.d.ts +@@ -4545,6 +4545,522 @@ export class DistributionBucketFamilyMetadata implements IDistributionBucketFami + public toJSON(): { [k: string]: any }; + } + ++/** Properties of a CreatorTokenIssuerRemarked. */ ++export interface ICreatorTokenIssuerRemarked { ++ ++ /** CreatorTokenIssuerRemarked updateTokenMetadata */ ++ updateTokenMetadata?: (IUpdateTokenMetadata|null); ++} ++ ++/** Represents a CreatorTokenIssuerRemarked. */ ++export class CreatorTokenIssuerRemarked implements ICreatorTokenIssuerRemarked { ++ ++ /** ++ * Constructs a new CreatorTokenIssuerRemarked. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: ICreatorTokenIssuerRemarked); ++ ++ /** CreatorTokenIssuerRemarked updateTokenMetadata. */ ++ public updateTokenMetadata?: (IUpdateTokenMetadata|null); ++ ++ /** CreatorTokenIssuerRemarked creatorTokenIssuerRemarked. */ ++ public creatorTokenIssuerRemarked?: "updateTokenMetadata"; ++ ++ /** ++ * Creates a new CreatorTokenIssuerRemarked instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns CreatorTokenIssuerRemarked instance ++ */ ++ public static create(properties?: ICreatorTokenIssuerRemarked): CreatorTokenIssuerRemarked; ++ ++ /** ++ * Encodes the specified CreatorTokenIssuerRemarked message. Does not implicitly {@link CreatorTokenIssuerRemarked.verify|verify} messages. ++ * @param message CreatorTokenIssuerRemarked message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: ICreatorTokenIssuerRemarked, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified CreatorTokenIssuerRemarked message, length delimited. Does not implicitly {@link CreatorTokenIssuerRemarked.verify|verify} messages. ++ * @param message CreatorTokenIssuerRemarked message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: ICreatorTokenIssuerRemarked, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a CreatorTokenIssuerRemarked message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns CreatorTokenIssuerRemarked ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): CreatorTokenIssuerRemarked; ++ ++ /** ++ * Decodes a CreatorTokenIssuerRemarked message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns CreatorTokenIssuerRemarked ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): CreatorTokenIssuerRemarked; ++ ++ /** ++ * Verifies a CreatorTokenIssuerRemarked message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a CreatorTokenIssuerRemarked message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns CreatorTokenIssuerRemarked ++ */ ++ public static fromObject(object: { [k: string]: any }): CreatorTokenIssuerRemarked; ++ ++ /** ++ * Creates a plain object from a CreatorTokenIssuerRemarked message. Also converts values to other types if specified. ++ * @param message CreatorTokenIssuerRemarked ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: CreatorTokenIssuerRemarked, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this CreatorTokenIssuerRemarked to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of an UpdateTokenMetadata. */ ++export interface IUpdateTokenMetadata { ++ ++ /** UpdateTokenMetadata newMetadata */ ++ newMetadata?: (ITokenMetadata|null); ++} ++ ++/** Represents an UpdateTokenMetadata. */ ++export class UpdateTokenMetadata implements IUpdateTokenMetadata { ++ ++ /** ++ * Constructs a new UpdateTokenMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IUpdateTokenMetadata); ++ ++ /** UpdateTokenMetadata newMetadata. */ ++ public newMetadata?: (ITokenMetadata|null); ++ ++ /** ++ * Creates a new UpdateTokenMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns UpdateTokenMetadata instance ++ */ ++ public static create(properties?: IUpdateTokenMetadata): UpdateTokenMetadata; ++ ++ /** ++ * Encodes the specified UpdateTokenMetadata message. Does not implicitly {@link UpdateTokenMetadata.verify|verify} messages. ++ * @param message UpdateTokenMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IUpdateTokenMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified UpdateTokenMetadata message, length delimited. Does not implicitly {@link UpdateTokenMetadata.verify|verify} messages. ++ * @param message UpdateTokenMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IUpdateTokenMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes an UpdateTokenMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns UpdateTokenMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): UpdateTokenMetadata; ++ ++ /** ++ * Decodes an UpdateTokenMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns UpdateTokenMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): UpdateTokenMetadata; ++ ++ /** ++ * Verifies an UpdateTokenMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates an UpdateTokenMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns UpdateTokenMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): UpdateTokenMetadata; ++ ++ /** ++ * Creates a plain object from an UpdateTokenMetadata message. Also converts values to other types if specified. ++ * @param message UpdateTokenMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: UpdateTokenMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this UpdateTokenMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a TokenMetadata. */ ++export interface ITokenMetadata { ++ ++ /** TokenMetadata name */ ++ name?: (string|null); ++ ++ /** TokenMetadata description */ ++ description?: (string|null); ++ ++ /** TokenMetadata avatarObject */ ++ avatarObject?: (number|null); ++ ++ /** TokenMetadata avatarUri */ ++ avatarUri?: (string|null); ++ ++ /** TokenMetadata benefits */ ++ benefits?: (IBenefit[]|null); ++ ++ /** TokenMetadata whitelistApplicationNote */ ++ whitelistApplicationNote?: (string|null); ++ ++ /** TokenMetadata whitelistApplicationApplyLink */ ++ whitelistApplicationApplyLink?: (string|null); ++ ++ /** TokenMetadata trailerVideoId */ ++ trailerVideoId?: (Long|null); ++} ++ ++/** Represents a TokenMetadata. */ ++export class TokenMetadata implements ITokenMetadata { ++ ++ /** ++ * Constructs a new TokenMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: ITokenMetadata); ++ ++ /** TokenMetadata name. */ ++ public name: string; ++ ++ /** TokenMetadata description. */ ++ public description: string; ++ ++ /** TokenMetadata avatarObject. */ ++ public avatarObject?: (number|null); ++ ++ /** TokenMetadata avatarUri. */ ++ public avatarUri?: (string|null); ++ ++ /** TokenMetadata benefits. */ ++ public benefits: IBenefit[]; ++ ++ /** TokenMetadata whitelistApplicationNote. */ ++ public whitelistApplicationNote: string; ++ ++ /** TokenMetadata whitelistApplicationApplyLink. */ ++ public whitelistApplicationApplyLink: string; ++ ++ /** TokenMetadata trailerVideoId. */ ++ public trailerVideoId: Long; ++ ++ /** TokenMetadata avatar. */ ++ public avatar?: ("avatarObject"|"avatarUri"); ++ ++ /** ++ * Creates a new TokenMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns TokenMetadata instance ++ */ ++ public static create(properties?: ITokenMetadata): TokenMetadata; ++ ++ /** ++ * Encodes the specified TokenMetadata message. Does not implicitly {@link TokenMetadata.verify|verify} messages. ++ * @param message TokenMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: ITokenMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified TokenMetadata message, length delimited. Does not implicitly {@link TokenMetadata.verify|verify} messages. ++ * @param message TokenMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: ITokenMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a TokenMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns TokenMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): TokenMetadata; ++ ++ /** ++ * Decodes a TokenMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns TokenMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): TokenMetadata; ++ ++ /** ++ * Verifies a TokenMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a TokenMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns TokenMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): TokenMetadata; ++ ++ /** ++ * Creates a plain object from a TokenMetadata message. Also converts values to other types if specified. ++ * @param message TokenMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: TokenMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this TokenMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a Benefit. */ ++export interface IBenefit { ++ ++ /** Benefit title */ ++ title?: (string|null); ++ ++ /** Benefit description */ ++ description?: (string|null); ++ ++ /** Benefit emoji */ ++ emoji?: (string|null); ++ ++ /** Benefit displayOrder */ ++ displayOrder?: (number|null); ++} ++ ++/** Represents a Benefit. */ ++export class Benefit implements IBenefit { ++ ++ /** ++ * Constructs a new Benefit. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IBenefit); ++ ++ /** Benefit title. */ ++ public title: string; ++ ++ /** Benefit description. */ ++ public description: string; ++ ++ /** Benefit emoji. */ ++ public emoji: string; ++ ++ /** Benefit displayOrder. */ ++ public displayOrder: number; ++ ++ /** ++ * Creates a new Benefit instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns Benefit instance ++ */ ++ public static create(properties?: IBenefit): Benefit; ++ ++ /** ++ * Encodes the specified Benefit message. Does not implicitly {@link Benefit.verify|verify} messages. ++ * @param message Benefit message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IBenefit, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified Benefit message, length delimited. Does not implicitly {@link Benefit.verify|verify} messages. ++ * @param message Benefit message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IBenefit, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a Benefit message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns Benefit ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): Benefit; ++ ++ /** ++ * Decodes a Benefit message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns Benefit ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): Benefit; ++ ++ /** ++ * Verifies a Benefit message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a Benefit message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns Benefit ++ */ ++ public static fromObject(object: { [k: string]: any }): Benefit; ++ ++ /** ++ * Creates a plain object from a Benefit message. Also converts values to other types if specified. ++ * @param message Benefit ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: Benefit, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this Benefit to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a SaleMetadata. */ ++export interface ISaleMetadata { ++ ++ /** SaleMetadata termsAndConditions */ ++ termsAndConditions?: (string|null); ++} ++ ++/** Represents a SaleMetadata. */ ++export class SaleMetadata implements ISaleMetadata { ++ ++ /** ++ * Constructs a new SaleMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: ISaleMetadata); ++ ++ /** SaleMetadata termsAndConditions. */ ++ public termsAndConditions: string; ++ ++ /** ++ * Creates a new SaleMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns SaleMetadata instance ++ */ ++ public static create(properties?: ISaleMetadata): SaleMetadata; ++ ++ /** ++ * Encodes the specified SaleMetadata message. Does not implicitly {@link SaleMetadata.verify|verify} messages. ++ * @param message SaleMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: ISaleMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified SaleMetadata message, length delimited. Does not implicitly {@link SaleMetadata.verify|verify} messages. ++ * @param message SaleMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: ISaleMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a SaleMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns SaleMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): SaleMetadata; ++ ++ /** ++ * Decodes a SaleMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns SaleMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): SaleMetadata; ++ ++ /** ++ * Verifies a SaleMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a SaleMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns SaleMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): SaleMetadata; ++ ++ /** ++ * Creates a plain object from a SaleMetadata message. Also converts values to other types if specified. ++ * @param message SaleMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: SaleMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this SaleMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ + /** Properties of a PublishedBeforeJoystream. */ + export interface IPublishedBeforeJoystream { + +diff --git a/node_modules/@joystream/metadata-protobuf/compiled/index.js b/node_modules/@joystream/metadata-protobuf/compiled/index.js +old mode 100755 +new mode 100644 +index 2e7a59c..824d80c +--- a/node_modules/@joystream/metadata-protobuf/compiled/index.js ++++ b/node_modules/@joystream/metadata-protobuf/compiled/index.js +@@ -11132,6 +11132,1253 @@ $root.DistributionBucketFamilyMetadata = (function() { + return DistributionBucketFamilyMetadata; + })(); + ++$root.CreatorTokenIssuerRemarked = (function() { ++ ++ /** ++ * Properties of a CreatorTokenIssuerRemarked. ++ * @exports ICreatorTokenIssuerRemarked ++ * @interface ICreatorTokenIssuerRemarked ++ * @property {IUpdateTokenMetadata|null} [updateTokenMetadata] CreatorTokenIssuerRemarked updateTokenMetadata ++ */ ++ ++ /** ++ * Constructs a new CreatorTokenIssuerRemarked. ++ * @exports CreatorTokenIssuerRemarked ++ * @classdesc Represents a CreatorTokenIssuerRemarked. ++ * @implements ICreatorTokenIssuerRemarked ++ * @constructor ++ * @param {ICreatorTokenIssuerRemarked=} [properties] Properties to set ++ */ ++ function CreatorTokenIssuerRemarked(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * CreatorTokenIssuerRemarked updateTokenMetadata. ++ * @member {IUpdateTokenMetadata|null|undefined} updateTokenMetadata ++ * @memberof CreatorTokenIssuerRemarked ++ * @instance ++ */ ++ CreatorTokenIssuerRemarked.prototype.updateTokenMetadata = null; ++ ++ // OneOf field names bound to virtual getters and setters ++ var $oneOfFields; ++ ++ /** ++ * CreatorTokenIssuerRemarked creatorTokenIssuerRemarked. ++ * @member {"updateTokenMetadata"|undefined} creatorTokenIssuerRemarked ++ * @memberof CreatorTokenIssuerRemarked ++ * @instance ++ */ ++ Object.defineProperty(CreatorTokenIssuerRemarked.prototype, "creatorTokenIssuerRemarked", { ++ get: $util.oneOfGetter($oneOfFields = ["updateTokenMetadata"]), ++ set: $util.oneOfSetter($oneOfFields) ++ }); ++ ++ /** ++ * Creates a new CreatorTokenIssuerRemarked instance using the specified properties. ++ * @function create ++ * @memberof CreatorTokenIssuerRemarked ++ * @static ++ * @param {ICreatorTokenIssuerRemarked=} [properties] Properties to set ++ * @returns {CreatorTokenIssuerRemarked} CreatorTokenIssuerRemarked instance ++ */ ++ CreatorTokenIssuerRemarked.create = function create(properties) { ++ return new CreatorTokenIssuerRemarked(properties); ++ }; ++ ++ /** ++ * Encodes the specified CreatorTokenIssuerRemarked message. Does not implicitly {@link CreatorTokenIssuerRemarked.verify|verify} messages. ++ * @function encode ++ * @memberof CreatorTokenIssuerRemarked ++ * @static ++ * @param {ICreatorTokenIssuerRemarked} message CreatorTokenIssuerRemarked message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ CreatorTokenIssuerRemarked.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.updateTokenMetadata != null && Object.hasOwnProperty.call(message, "updateTokenMetadata")) ++ $root.UpdateTokenMetadata.encode(message.updateTokenMetadata, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified CreatorTokenIssuerRemarked message, length delimited. Does not implicitly {@link CreatorTokenIssuerRemarked.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof CreatorTokenIssuerRemarked ++ * @static ++ * @param {ICreatorTokenIssuerRemarked} message CreatorTokenIssuerRemarked message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ CreatorTokenIssuerRemarked.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a CreatorTokenIssuerRemarked message from the specified reader or buffer. ++ * @function decode ++ * @memberof CreatorTokenIssuerRemarked ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {CreatorTokenIssuerRemarked} CreatorTokenIssuerRemarked ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ CreatorTokenIssuerRemarked.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.CreatorTokenIssuerRemarked(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.updateTokenMetadata = $root.UpdateTokenMetadata.decode(reader, reader.uint32()); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a CreatorTokenIssuerRemarked message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof CreatorTokenIssuerRemarked ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {CreatorTokenIssuerRemarked} CreatorTokenIssuerRemarked ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ CreatorTokenIssuerRemarked.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a CreatorTokenIssuerRemarked message. ++ * @function verify ++ * @memberof CreatorTokenIssuerRemarked ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ CreatorTokenIssuerRemarked.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ var properties = {}; ++ if (message.updateTokenMetadata != null && message.hasOwnProperty("updateTokenMetadata")) { ++ properties.creatorTokenIssuerRemarked = 1; ++ { ++ var error = $root.UpdateTokenMetadata.verify(message.updateTokenMetadata); ++ if (error) ++ return "updateTokenMetadata." + error; ++ } ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates a CreatorTokenIssuerRemarked message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof CreatorTokenIssuerRemarked ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {CreatorTokenIssuerRemarked} CreatorTokenIssuerRemarked ++ */ ++ CreatorTokenIssuerRemarked.fromObject = function fromObject(object) { ++ if (object instanceof $root.CreatorTokenIssuerRemarked) ++ return object; ++ var message = new $root.CreatorTokenIssuerRemarked(); ++ if (object.updateTokenMetadata != null) { ++ if (typeof object.updateTokenMetadata !== "object") ++ throw TypeError(".CreatorTokenIssuerRemarked.updateTokenMetadata: object expected"); ++ message.updateTokenMetadata = $root.UpdateTokenMetadata.fromObject(object.updateTokenMetadata); ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a CreatorTokenIssuerRemarked message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof CreatorTokenIssuerRemarked ++ * @static ++ * @param {CreatorTokenIssuerRemarked} message CreatorTokenIssuerRemarked ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ CreatorTokenIssuerRemarked.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (message.updateTokenMetadata != null && message.hasOwnProperty("updateTokenMetadata")) { ++ object.updateTokenMetadata = $root.UpdateTokenMetadata.toObject(message.updateTokenMetadata, options); ++ if (options.oneofs) ++ object.creatorTokenIssuerRemarked = "updateTokenMetadata"; ++ } ++ return object; ++ }; ++ ++ /** ++ * Converts this CreatorTokenIssuerRemarked to JSON. ++ * @function toJSON ++ * @memberof CreatorTokenIssuerRemarked ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ CreatorTokenIssuerRemarked.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return CreatorTokenIssuerRemarked; ++})(); ++ ++$root.UpdateTokenMetadata = (function() { ++ ++ /** ++ * Properties of an UpdateTokenMetadata. ++ * @exports IUpdateTokenMetadata ++ * @interface IUpdateTokenMetadata ++ * @property {ITokenMetadata|null} [newMetadata] UpdateTokenMetadata newMetadata ++ */ ++ ++ /** ++ * Constructs a new UpdateTokenMetadata. ++ * @exports UpdateTokenMetadata ++ * @classdesc Represents an UpdateTokenMetadata. ++ * @implements IUpdateTokenMetadata ++ * @constructor ++ * @param {IUpdateTokenMetadata=} [properties] Properties to set ++ */ ++ function UpdateTokenMetadata(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * UpdateTokenMetadata newMetadata. ++ * @member {ITokenMetadata|null|undefined} newMetadata ++ * @memberof UpdateTokenMetadata ++ * @instance ++ */ ++ UpdateTokenMetadata.prototype.newMetadata = null; ++ ++ /** ++ * Creates a new UpdateTokenMetadata instance using the specified properties. ++ * @function create ++ * @memberof UpdateTokenMetadata ++ * @static ++ * @param {IUpdateTokenMetadata=} [properties] Properties to set ++ * @returns {UpdateTokenMetadata} UpdateTokenMetadata instance ++ */ ++ UpdateTokenMetadata.create = function create(properties) { ++ return new UpdateTokenMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified UpdateTokenMetadata message. Does not implicitly {@link UpdateTokenMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof UpdateTokenMetadata ++ * @static ++ * @param {IUpdateTokenMetadata} message UpdateTokenMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ UpdateTokenMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.newMetadata != null && Object.hasOwnProperty.call(message, "newMetadata")) ++ $root.TokenMetadata.encode(message.newMetadata, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified UpdateTokenMetadata message, length delimited. Does not implicitly {@link UpdateTokenMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof UpdateTokenMetadata ++ * @static ++ * @param {IUpdateTokenMetadata} message UpdateTokenMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ UpdateTokenMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes an UpdateTokenMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof UpdateTokenMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {UpdateTokenMetadata} UpdateTokenMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ UpdateTokenMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.UpdateTokenMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.newMetadata = $root.TokenMetadata.decode(reader, reader.uint32()); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes an UpdateTokenMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof UpdateTokenMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {UpdateTokenMetadata} UpdateTokenMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ UpdateTokenMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies an UpdateTokenMetadata message. ++ * @function verify ++ * @memberof UpdateTokenMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ UpdateTokenMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.newMetadata != null && message.hasOwnProperty("newMetadata")) { ++ var error = $root.TokenMetadata.verify(message.newMetadata); ++ if (error) ++ return "newMetadata." + error; ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates an UpdateTokenMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof UpdateTokenMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {UpdateTokenMetadata} UpdateTokenMetadata ++ */ ++ UpdateTokenMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.UpdateTokenMetadata) ++ return object; ++ var message = new $root.UpdateTokenMetadata(); ++ if (object.newMetadata != null) { ++ if (typeof object.newMetadata !== "object") ++ throw TypeError(".UpdateTokenMetadata.newMetadata: object expected"); ++ message.newMetadata = $root.TokenMetadata.fromObject(object.newMetadata); ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from an UpdateTokenMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof UpdateTokenMetadata ++ * @static ++ * @param {UpdateTokenMetadata} message UpdateTokenMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ UpdateTokenMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) ++ object.newMetadata = null; ++ if (message.newMetadata != null && message.hasOwnProperty("newMetadata")) ++ object.newMetadata = $root.TokenMetadata.toObject(message.newMetadata, options); ++ return object; ++ }; ++ ++ /** ++ * Converts this UpdateTokenMetadata to JSON. ++ * @function toJSON ++ * @memberof UpdateTokenMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ UpdateTokenMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return UpdateTokenMetadata; ++})(); ++ ++$root.TokenMetadata = (function() { ++ ++ /** ++ * Properties of a TokenMetadata. ++ * @exports ITokenMetadata ++ * @interface ITokenMetadata ++ * @property {string|null} [name] TokenMetadata name ++ * @property {string|null} [description] TokenMetadata description ++ * @property {number|null} [avatarObject] TokenMetadata avatarObject ++ * @property {string|null} [avatarUri] TokenMetadata avatarUri ++ * @property {Array.|null} [benefits] TokenMetadata benefits ++ * @property {string|null} [whitelistApplicationNote] TokenMetadata whitelistApplicationNote ++ * @property {string|null} [whitelistApplicationApplyLink] TokenMetadata whitelistApplicationApplyLink ++ * @property {Long|null} [trailerVideoId] TokenMetadata trailerVideoId ++ */ ++ ++ /** ++ * Constructs a new TokenMetadata. ++ * @exports TokenMetadata ++ * @classdesc Represents a TokenMetadata. ++ * @implements ITokenMetadata ++ * @constructor ++ * @param {ITokenMetadata=} [properties] Properties to set ++ */ ++ function TokenMetadata(properties) { ++ this.benefits = []; ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * TokenMetadata name. ++ * @member {string} name ++ * @memberof TokenMetadata ++ * @instance ++ */ ++ TokenMetadata.prototype.name = ""; ++ ++ /** ++ * TokenMetadata description. ++ * @member {string} description ++ * @memberof TokenMetadata ++ * @instance ++ */ ++ TokenMetadata.prototype.description = ""; ++ ++ /** ++ * TokenMetadata avatarObject. ++ * @member {number|null|undefined} avatarObject ++ * @memberof TokenMetadata ++ * @instance ++ */ ++ TokenMetadata.prototype.avatarObject = null; ++ ++ /** ++ * TokenMetadata avatarUri. ++ * @member {string|null|undefined} avatarUri ++ * @memberof TokenMetadata ++ * @instance ++ */ ++ TokenMetadata.prototype.avatarUri = null; ++ ++ /** ++ * TokenMetadata benefits. ++ * @member {Array.} benefits ++ * @memberof TokenMetadata ++ * @instance ++ */ ++ TokenMetadata.prototype.benefits = $util.emptyArray; ++ ++ /** ++ * TokenMetadata whitelistApplicationNote. ++ * @member {string} whitelistApplicationNote ++ * @memberof TokenMetadata ++ * @instance ++ */ ++ TokenMetadata.prototype.whitelistApplicationNote = ""; ++ ++ /** ++ * TokenMetadata whitelistApplicationApplyLink. ++ * @member {string} whitelistApplicationApplyLink ++ * @memberof TokenMetadata ++ * @instance ++ */ ++ TokenMetadata.prototype.whitelistApplicationApplyLink = ""; ++ ++ /** ++ * TokenMetadata trailerVideoId. ++ * @member {Long} trailerVideoId ++ * @memberof TokenMetadata ++ * @instance ++ */ ++ TokenMetadata.prototype.trailerVideoId = $util.Long ? $util.Long.fromBits(0,0,true) : 0; ++ ++ // OneOf field names bound to virtual getters and setters ++ var $oneOfFields; ++ ++ /** ++ * TokenMetadata avatar. ++ * @member {"avatarObject"|"avatarUri"|undefined} avatar ++ * @memberof TokenMetadata ++ * @instance ++ */ ++ Object.defineProperty(TokenMetadata.prototype, "avatar", { ++ get: $util.oneOfGetter($oneOfFields = ["avatarObject", "avatarUri"]), ++ set: $util.oneOfSetter($oneOfFields) ++ }); ++ ++ /** ++ * Creates a new TokenMetadata instance using the specified properties. ++ * @function create ++ * @memberof TokenMetadata ++ * @static ++ * @param {ITokenMetadata=} [properties] Properties to set ++ * @returns {TokenMetadata} TokenMetadata instance ++ */ ++ TokenMetadata.create = function create(properties) { ++ return new TokenMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified TokenMetadata message. Does not implicitly {@link TokenMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof TokenMetadata ++ * @static ++ * @param {ITokenMetadata} message TokenMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ TokenMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.name != null && Object.hasOwnProperty.call(message, "name")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.name); ++ if (message.description != null && Object.hasOwnProperty.call(message, "description")) ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.description); ++ if (message.avatarObject != null && Object.hasOwnProperty.call(message, "avatarObject")) ++ writer.uint32(/* id 3, wireType 0 =*/24).uint32(message.avatarObject); ++ if (message.avatarUri != null && Object.hasOwnProperty.call(message, "avatarUri")) ++ writer.uint32(/* id 4, wireType 2 =*/34).string(message.avatarUri); ++ if (message.benefits != null && message.benefits.length) ++ for (var i = 0; i < message.benefits.length; ++i) ++ $root.Benefit.encode(message.benefits[i], writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim(); ++ if (message.whitelistApplicationNote != null && Object.hasOwnProperty.call(message, "whitelistApplicationNote")) ++ writer.uint32(/* id 6, wireType 2 =*/50).string(message.whitelistApplicationNote); ++ if (message.whitelistApplicationApplyLink != null && Object.hasOwnProperty.call(message, "whitelistApplicationApplyLink")) ++ writer.uint32(/* id 7, wireType 2 =*/58).string(message.whitelistApplicationApplyLink); ++ if (message.trailerVideoId != null && Object.hasOwnProperty.call(message, "trailerVideoId")) ++ writer.uint32(/* id 8, wireType 0 =*/64).uint64(message.trailerVideoId); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified TokenMetadata message, length delimited. Does not implicitly {@link TokenMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof TokenMetadata ++ * @static ++ * @param {ITokenMetadata} message TokenMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ TokenMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a TokenMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof TokenMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {TokenMetadata} TokenMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ TokenMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.TokenMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.name = reader.string(); ++ break; ++ case 2: ++ message.description = reader.string(); ++ break; ++ case 3: ++ message.avatarObject = reader.uint32(); ++ break; ++ case 4: ++ message.avatarUri = reader.string(); ++ break; ++ case 5: ++ if (!(message.benefits && message.benefits.length)) ++ message.benefits = []; ++ message.benefits.push($root.Benefit.decode(reader, reader.uint32())); ++ break; ++ case 6: ++ message.whitelistApplicationNote = reader.string(); ++ break; ++ case 7: ++ message.whitelistApplicationApplyLink = reader.string(); ++ break; ++ case 8: ++ message.trailerVideoId = reader.uint64(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a TokenMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof TokenMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {TokenMetadata} TokenMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ TokenMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a TokenMetadata message. ++ * @function verify ++ * @memberof TokenMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ TokenMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ var properties = {}; ++ if (message.name != null && message.hasOwnProperty("name")) ++ if (!$util.isString(message.name)) ++ return "name: string expected"; ++ if (message.description != null && message.hasOwnProperty("description")) ++ if (!$util.isString(message.description)) ++ return "description: string expected"; ++ if (message.avatarObject != null && message.hasOwnProperty("avatarObject")) { ++ properties.avatar = 1; ++ if (!$util.isInteger(message.avatarObject)) ++ return "avatarObject: integer expected"; ++ } ++ if (message.avatarUri != null && message.hasOwnProperty("avatarUri")) { ++ if (properties.avatar === 1) ++ return "avatar: multiple values"; ++ properties.avatar = 1; ++ if (!$util.isString(message.avatarUri)) ++ return "avatarUri: string expected"; ++ } ++ if (message.benefits != null && message.hasOwnProperty("benefits")) { ++ if (!Array.isArray(message.benefits)) ++ return "benefits: array expected"; ++ for (var i = 0; i < message.benefits.length; ++i) { ++ var error = $root.Benefit.verify(message.benefits[i]); ++ if (error) ++ return "benefits." + error; ++ } ++ } ++ if (message.whitelistApplicationNote != null && message.hasOwnProperty("whitelistApplicationNote")) ++ if (!$util.isString(message.whitelistApplicationNote)) ++ return "whitelistApplicationNote: string expected"; ++ if (message.whitelistApplicationApplyLink != null && message.hasOwnProperty("whitelistApplicationApplyLink")) ++ if (!$util.isString(message.whitelistApplicationApplyLink)) ++ return "whitelistApplicationApplyLink: string expected"; ++ if (message.trailerVideoId != null && message.hasOwnProperty("trailerVideoId")) ++ if (!$util.isInteger(message.trailerVideoId) && !(message.trailerVideoId && $util.isInteger(message.trailerVideoId.low) && $util.isInteger(message.trailerVideoId.high))) ++ return "trailerVideoId: integer|Long expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a TokenMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof TokenMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {TokenMetadata} TokenMetadata ++ */ ++ TokenMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.TokenMetadata) ++ return object; ++ var message = new $root.TokenMetadata(); ++ if (object.name != null) ++ message.name = String(object.name); ++ if (object.description != null) ++ message.description = String(object.description); ++ if (object.avatarObject != null) ++ message.avatarObject = object.avatarObject >>> 0; ++ if (object.avatarUri != null) ++ message.avatarUri = String(object.avatarUri); ++ if (object.benefits) { ++ if (!Array.isArray(object.benefits)) ++ throw TypeError(".TokenMetadata.benefits: array expected"); ++ message.benefits = []; ++ for (var i = 0; i < object.benefits.length; ++i) { ++ if (typeof object.benefits[i] !== "object") ++ throw TypeError(".TokenMetadata.benefits: object expected"); ++ message.benefits[i] = $root.Benefit.fromObject(object.benefits[i]); ++ } ++ } ++ if (object.whitelistApplicationNote != null) ++ message.whitelistApplicationNote = String(object.whitelistApplicationNote); ++ if (object.whitelistApplicationApplyLink != null) ++ message.whitelistApplicationApplyLink = String(object.whitelistApplicationApplyLink); ++ if (object.trailerVideoId != null) ++ if ($util.Long) ++ (message.trailerVideoId = $util.Long.fromValue(object.trailerVideoId)).unsigned = true; ++ else if (typeof object.trailerVideoId === "string") ++ message.trailerVideoId = parseInt(object.trailerVideoId, 10); ++ else if (typeof object.trailerVideoId === "number") ++ message.trailerVideoId = object.trailerVideoId; ++ else if (typeof object.trailerVideoId === "object") ++ message.trailerVideoId = new $util.LongBits(object.trailerVideoId.low >>> 0, object.trailerVideoId.high >>> 0).toNumber(true); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a TokenMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof TokenMetadata ++ * @static ++ * @param {TokenMetadata} message TokenMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ TokenMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.arrays || options.defaults) ++ object.benefits = []; ++ if (options.defaults) { ++ object.name = ""; ++ object.description = ""; ++ object.whitelistApplicationNote = ""; ++ object.whitelistApplicationApplyLink = ""; ++ if ($util.Long) { ++ var long = new $util.Long(0, 0, true); ++ object.trailerVideoId = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; ++ } else ++ object.trailerVideoId = options.longs === String ? "0" : 0; ++ } ++ if (message.name != null && message.hasOwnProperty("name")) ++ object.name = message.name; ++ if (message.description != null && message.hasOwnProperty("description")) ++ object.description = message.description; ++ if (message.avatarObject != null && message.hasOwnProperty("avatarObject")) { ++ object.avatarObject = message.avatarObject; ++ if (options.oneofs) ++ object.avatar = "avatarObject"; ++ } ++ if (message.avatarUri != null && message.hasOwnProperty("avatarUri")) { ++ object.avatarUri = message.avatarUri; ++ if (options.oneofs) ++ object.avatar = "avatarUri"; ++ } ++ if (message.benefits && message.benefits.length) { ++ object.benefits = []; ++ for (var j = 0; j < message.benefits.length; ++j) ++ object.benefits[j] = $root.Benefit.toObject(message.benefits[j], options); ++ } ++ if (message.whitelistApplicationNote != null && message.hasOwnProperty("whitelistApplicationNote")) ++ object.whitelistApplicationNote = message.whitelistApplicationNote; ++ if (message.whitelistApplicationApplyLink != null && message.hasOwnProperty("whitelistApplicationApplyLink")) ++ object.whitelistApplicationApplyLink = message.whitelistApplicationApplyLink; ++ if (message.trailerVideoId != null && message.hasOwnProperty("trailerVideoId")) ++ if (typeof message.trailerVideoId === "number") ++ object.trailerVideoId = options.longs === String ? String(message.trailerVideoId) : message.trailerVideoId; ++ else ++ object.trailerVideoId = options.longs === String ? $util.Long.prototype.toString.call(message.trailerVideoId) : options.longs === Number ? new $util.LongBits(message.trailerVideoId.low >>> 0, message.trailerVideoId.high >>> 0).toNumber(true) : message.trailerVideoId; ++ return object; ++ }; ++ ++ /** ++ * Converts this TokenMetadata to JSON. ++ * @function toJSON ++ * @memberof TokenMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ TokenMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return TokenMetadata; ++})(); ++ ++$root.Benefit = (function() { ++ ++ /** ++ * Properties of a Benefit. ++ * @exports IBenefit ++ * @interface IBenefit ++ * @property {string|null} [title] Benefit title ++ * @property {string|null} [description] Benefit description ++ * @property {string|null} [emoji] Benefit emoji ++ * @property {number|null} [displayOrder] Benefit displayOrder ++ */ ++ ++ /** ++ * Constructs a new Benefit. ++ * @exports Benefit ++ * @classdesc Represents a Benefit. ++ * @implements IBenefit ++ * @constructor ++ * @param {IBenefit=} [properties] Properties to set ++ */ ++ function Benefit(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * Benefit title. ++ * @member {string} title ++ * @memberof Benefit ++ * @instance ++ */ ++ Benefit.prototype.title = ""; ++ ++ /** ++ * Benefit description. ++ * @member {string} description ++ * @memberof Benefit ++ * @instance ++ */ ++ Benefit.prototype.description = ""; ++ ++ /** ++ * Benefit emoji. ++ * @member {string} emoji ++ * @memberof Benefit ++ * @instance ++ */ ++ Benefit.prototype.emoji = ""; ++ ++ /** ++ * Benefit displayOrder. ++ * @member {number} displayOrder ++ * @memberof Benefit ++ * @instance ++ */ ++ Benefit.prototype.displayOrder = 0; ++ ++ /** ++ * Creates a new Benefit instance using the specified properties. ++ * @function create ++ * @memberof Benefit ++ * @static ++ * @param {IBenefit=} [properties] Properties to set ++ * @returns {Benefit} Benefit instance ++ */ ++ Benefit.create = function create(properties) { ++ return new Benefit(properties); ++ }; ++ ++ /** ++ * Encodes the specified Benefit message. Does not implicitly {@link Benefit.verify|verify} messages. ++ * @function encode ++ * @memberof Benefit ++ * @static ++ * @param {IBenefit} message Benefit message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ Benefit.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.title != null && Object.hasOwnProperty.call(message, "title")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.title); ++ if (message.description != null && Object.hasOwnProperty.call(message, "description")) ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.description); ++ if (message.emoji != null && Object.hasOwnProperty.call(message, "emoji")) ++ writer.uint32(/* id 3, wireType 2 =*/26).string(message.emoji); ++ if (message.displayOrder != null && Object.hasOwnProperty.call(message, "displayOrder")) ++ writer.uint32(/* id 4, wireType 0 =*/32).uint32(message.displayOrder); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified Benefit message, length delimited. Does not implicitly {@link Benefit.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof Benefit ++ * @static ++ * @param {IBenefit} message Benefit message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ Benefit.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a Benefit message from the specified reader or buffer. ++ * @function decode ++ * @memberof Benefit ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {Benefit} Benefit ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ Benefit.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.Benefit(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.title = reader.string(); ++ break; ++ case 2: ++ message.description = reader.string(); ++ break; ++ case 3: ++ message.emoji = reader.string(); ++ break; ++ case 4: ++ message.displayOrder = reader.uint32(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a Benefit message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof Benefit ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {Benefit} Benefit ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ Benefit.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a Benefit message. ++ * @function verify ++ * @memberof Benefit ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ Benefit.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.title != null && message.hasOwnProperty("title")) ++ if (!$util.isString(message.title)) ++ return "title: string expected"; ++ if (message.description != null && message.hasOwnProperty("description")) ++ if (!$util.isString(message.description)) ++ return "description: string expected"; ++ if (message.emoji != null && message.hasOwnProperty("emoji")) ++ if (!$util.isString(message.emoji)) ++ return "emoji: string expected"; ++ if (message.displayOrder != null && message.hasOwnProperty("displayOrder")) ++ if (!$util.isInteger(message.displayOrder)) ++ return "displayOrder: integer expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a Benefit message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof Benefit ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {Benefit} Benefit ++ */ ++ Benefit.fromObject = function fromObject(object) { ++ if (object instanceof $root.Benefit) ++ return object; ++ var message = new $root.Benefit(); ++ if (object.title != null) ++ message.title = String(object.title); ++ if (object.description != null) ++ message.description = String(object.description); ++ if (object.emoji != null) ++ message.emoji = String(object.emoji); ++ if (object.displayOrder != null) ++ message.displayOrder = object.displayOrder >>> 0; ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a Benefit message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof Benefit ++ * @static ++ * @param {Benefit} message Benefit ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ Benefit.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.title = ""; ++ object.description = ""; ++ object.emoji = ""; ++ object.displayOrder = 0; ++ } ++ if (message.title != null && message.hasOwnProperty("title")) ++ object.title = message.title; ++ if (message.description != null && message.hasOwnProperty("description")) ++ object.description = message.description; ++ if (message.emoji != null && message.hasOwnProperty("emoji")) ++ object.emoji = message.emoji; ++ if (message.displayOrder != null && message.hasOwnProperty("displayOrder")) ++ object.displayOrder = message.displayOrder; ++ return object; ++ }; ++ ++ /** ++ * Converts this Benefit to JSON. ++ * @function toJSON ++ * @memberof Benefit ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ Benefit.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return Benefit; ++})(); ++ ++$root.SaleMetadata = (function() { ++ ++ /** ++ * Properties of a SaleMetadata. ++ * @exports ISaleMetadata ++ * @interface ISaleMetadata ++ * @property {string|null} [termsAndConditions] SaleMetadata termsAndConditions ++ */ ++ ++ /** ++ * Constructs a new SaleMetadata. ++ * @exports SaleMetadata ++ * @classdesc Represents a SaleMetadata. ++ * @implements ISaleMetadata ++ * @constructor ++ * @param {ISaleMetadata=} [properties] Properties to set ++ */ ++ function SaleMetadata(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * SaleMetadata termsAndConditions. ++ * @member {string} termsAndConditions ++ * @memberof SaleMetadata ++ * @instance ++ */ ++ SaleMetadata.prototype.termsAndConditions = ""; ++ ++ /** ++ * Creates a new SaleMetadata instance using the specified properties. ++ * @function create ++ * @memberof SaleMetadata ++ * @static ++ * @param {ISaleMetadata=} [properties] Properties to set ++ * @returns {SaleMetadata} SaleMetadata instance ++ */ ++ SaleMetadata.create = function create(properties) { ++ return new SaleMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified SaleMetadata message. Does not implicitly {@link SaleMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof SaleMetadata ++ * @static ++ * @param {ISaleMetadata} message SaleMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ SaleMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.termsAndConditions != null && Object.hasOwnProperty.call(message, "termsAndConditions")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.termsAndConditions); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified SaleMetadata message, length delimited. Does not implicitly {@link SaleMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof SaleMetadata ++ * @static ++ * @param {ISaleMetadata} message SaleMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ SaleMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a SaleMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof SaleMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {SaleMetadata} SaleMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ SaleMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.SaleMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.termsAndConditions = reader.string(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a SaleMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof SaleMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {SaleMetadata} SaleMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ SaleMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a SaleMetadata message. ++ * @function verify ++ * @memberof SaleMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ SaleMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.termsAndConditions != null && message.hasOwnProperty("termsAndConditions")) ++ if (!$util.isString(message.termsAndConditions)) ++ return "termsAndConditions: string expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a SaleMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof SaleMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {SaleMetadata} SaleMetadata ++ */ ++ SaleMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.SaleMetadata) ++ return object; ++ var message = new $root.SaleMetadata(); ++ if (object.termsAndConditions != null) ++ message.termsAndConditions = String(object.termsAndConditions); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a SaleMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof SaleMetadata ++ * @static ++ * @param {SaleMetadata} message SaleMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ SaleMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) ++ object.termsAndConditions = ""; ++ if (message.termsAndConditions != null && message.hasOwnProperty("termsAndConditions")) ++ object.termsAndConditions = message.termsAndConditions; ++ return object; ++ }; ++ ++ /** ++ * Converts this SaleMetadata to JSON. ++ * @function toJSON ++ * @memberof SaleMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ SaleMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return SaleMetadata; ++})(); ++ + $root.PublishedBeforeJoystream = (function() { + + /** +diff --git a/node_modules/@joystream/metadata-protobuf/doc-appendix.md b/node_modules/@joystream/metadata-protobuf/doc-appendix.md +new file mode 100644 +index 0000000..b07cf18 +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/doc-appendix.md +@@ -0,0 +1,41 @@ ++ ++ ++## Referencing Assets ++ ++ ++Applications that process messages that contain a `uint32` field that references an asset such as a cover photo or video, should interpret this value as a zero based index into an array/vector that is received external (out of band) to the protobuf message. ++ ++Example in context of query-node processing the runtime event `VideoCreated` ++ ++```rust ++// Runtime event associated with creating a Video ++VideoCreated(video_id: VideoId, video: Video, assets: Vec, params: VideoCreationParameters) ++ ++struct VideoCreationParameters { ++ in_category: VideoCategoryId, ++ // binary serialized VideoMetadata protobuf message ++ meta: Vec, ++} ++ ++// suppose assets is a vector of two elements. This is the "out of band" array being referenced by the VideoMetadata message ++assets = [ ++ NewAsset::Uri("https://mydomain.net/thumbnail.png"), ++ NewAsset::Upload({ ++ content_id, ++ ipfs_hash, ++ size, ++ ... ++ }), ++]; ++ ++meta = VideoMetadata { ++ ... ++ // refers to second element: assets[1] which is being uploaded to the storage system ++ video: 1, ++ // refers to the first element assets[0] which is being referneced by a url string. ++ thumbnail_photo: 0, ++ ... ++}; ++``` +\ No newline at end of file +diff --git a/node_modules/@joystream/metadata-protobuf/generate-md-doc.sh b/node_modules/@joystream/metadata-protobuf/generate-md-doc.sh +new file mode 100755 +index 0000000..46b521b +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/generate-md-doc.sh +@@ -0,0 +1,13 @@ ++#!/usr/bin/env bash ++ ++# Directory to write generated documentation to ++OUT_DIR_DOC="./doc" ++mkdir -p ${OUT_DIR_DOC} ++ ++# Gernerate Markdown docs ++protoc \ ++ --doc_out="${OUT_DIR_DOC}" --doc_opt=markdown,index.md \ ++ proto/*.proto ++ ++# Append some custom docs to generated protocol docs ++cat doc-appendix.md >> ${OUT_DIR_DOC}/index.md +diff --git a/node_modules/@joystream/metadata-protobuf/lib/json/index.d.ts b/node_modules/@joystream/metadata-protobuf/lib/json/index.d.ts +new file mode 100644 +index 0000000..76f77af +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/lib/json/index.d.ts +@@ -0,0 +1,2 @@ ++import { nested } from './messages.json'; ++export default nested; +diff --git a/node_modules/@joystream/metadata-protobuf/lib/json/index.js b/node_modules/@joystream/metadata-protobuf/lib/json/index.js +new file mode 100644 +index 0000000..f8ced4e +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/lib/json/index.js +@@ -0,0 +1,4 @@ ++"use strict"; ++Object.defineProperty(exports, "__esModule", { value: true }); ++const messages_json_1 = require("./messages.json"); ++exports.default = messages_json_1.nested; +diff --git a/node_modules/@joystream/metadata-protobuf/lib/json/messages.json b/node_modules/@joystream/metadata-protobuf/lib/json/messages.json +new file mode 100644 +index 0000000..479c647 +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/lib/json/messages.json +@@ -0,0 +1,1348 @@ ++{ ++ "nested": { ++ "AppActionMetadata": { ++ "fields": { ++ "videoId": { ++ "type": "string", ++ "id": 2 ++ } ++ } ++ }, ++ "AppAction": { ++ "fields": { ++ "appId": { ++ "rule": "required", ++ "type": "string", ++ "id": 999 ++ }, ++ "metadata": { ++ "type": "bytes", ++ "id": 2 ++ }, ++ "rawAction": { ++ "type": "bytes", ++ "id": 3 ++ }, ++ "signature": { ++ "type": "bytes", ++ "id": 4 ++ } ++ }, ++ "nested": { ++ "ActionType": { ++ "values": { ++ "CREATE_VIDEO": 0, ++ "CREATE_CHANNEL": 1 ++ } ++ }, ++ "CreatorType": { ++ "values": { ++ "CHANNEL": 0, ++ "MEMBER": 1, ++ "CURATOR_GROUP": 2 ++ } ++ } ++ } ++ }, ++ "BountyMetadata": { ++ "fields": { ++ "title": { ++ "type": "string", ++ "id": 1 ++ }, ++ "description": { ++ "type": "string", ++ "id": 2 ++ }, ++ "discussionThread": { ++ "type": "uint64", ++ "id": 3 ++ }, ++ "bannerImageUri": { ++ "type": "string", ++ "id": 4 ++ } ++ } ++ }, ++ "BountyWorkData": { ++ "fields": { ++ "title": { ++ "type": "string", ++ "id": 1 ++ }, ++ "description": { ++ "type": "string", ++ "id": 2 ++ } ++ } ++ }, ++ "ChannelMetadata": { ++ "fields": { ++ "title": { ++ "type": "string", ++ "id": 1 ++ }, ++ "description": { ++ "type": "string", ++ "id": 2 ++ }, ++ "isPublic": { ++ "type": "bool", ++ "id": 3 ++ }, ++ "language": { ++ "type": "string", ++ "id": 4 ++ }, ++ "coverPhoto": { ++ "type": "uint32", ++ "id": 5 ++ }, ++ "avatarPhoto": { ++ "type": "uint32", ++ "id": 6 ++ } ++ } ++ }, ++ "ChannelPayoutsMetadata": { ++ "fields": { ++ "header": { ++ "rule": "required", ++ "type": "Header", ++ "id": 1 ++ }, ++ "body": { ++ "rule": "required", ++ "type": "Body", ++ "id": 2 ++ } ++ }, ++ "nested": { ++ "Header": { ++ "fields": { ++ "payloadLengthInBytes": { ++ "rule": "required", ++ "type": "fixed64", ++ "id": 1 ++ }, ++ "headerLengthInBytes": { ++ "rule": "required", ++ "type": "fixed64", ++ "id": 2 ++ }, ++ "numberOfChannels": { ++ "rule": "required", ++ "type": "fixed32", ++ "id": 3 ++ }, ++ "channelPayoutByteOffsets": { ++ "rule": "repeated", ++ "type": "ChannelPayoutByteOffset", ++ "id": 4 ++ } ++ }, ++ "nested": { ++ "ChannelPayoutByteOffset": { ++ "fields": { ++ "channelId": { ++ "rule": "required", ++ "type": "fixed32", ++ "id": 1 ++ }, ++ "byteOffset": { ++ "rule": "required", ++ "type": "fixed64", ++ "id": 2 ++ } ++ } ++ } ++ } ++ }, ++ "Body": { ++ "fields": { ++ "channelPayouts": { ++ "rule": "repeated", ++ "type": "ChannelPayoutProof", ++ "id": 1 ++ } ++ }, ++ "nested": { ++ "ChannelPayoutProof": { ++ "fields": { ++ "channelId": { ++ "rule": "required", ++ "type": "uint32", ++ "id": 1 ++ }, ++ "cumulativeRewardEarned": { ++ "rule": "required", ++ "type": "string", ++ "id": 2 ++ }, ++ "merkleBranch": { ++ "rule": "repeated", ++ "type": "ProofElement", ++ "id": 3 ++ }, ++ "reason": { ++ "rule": "required", ++ "type": "string", ++ "id": 4 ++ } ++ }, ++ "nested": { ++ "Side": { ++ "values": { ++ "Left": 0, ++ "Right": 1 ++ } ++ }, ++ "ProofElement": { ++ "fields": { ++ "hash": { ++ "rule": "required", ++ "type": "string", ++ "id": 1 ++ }, ++ "side": { ++ "rule": "required", ++ "type": "Side", ++ "id": 2 ++ } ++ } ++ } ++ } ++ } ++ } ++ } ++ } ++ }, ++ "CouncilCandidacyNoteMetadata": { ++ "fields": { ++ "header": { ++ "type": "string", ++ "id": 1 ++ }, ++ "bulletPoints": { ++ "rule": "repeated", ++ "type": "string", ++ "id": 2 ++ }, ++ "bannerImageUri": { ++ "type": "string", ++ "id": 3 ++ }, ++ "description": { ++ "type": "string", ++ "id": 4 ++ } ++ } ++ }, ++ "ForumPostMetadata": { ++ "fields": { ++ "text": { ++ "type": "string", ++ "id": 1 ++ }, ++ "repliesTo": { ++ "type": "uint32", ++ "id": 2 ++ } ++ } ++ }, ++ "ForumThreadMetadata": { ++ "fields": { ++ "title": { ++ "type": "string", ++ "id": 1 ++ }, ++ "tags": { ++ "rule": "repeated", ++ "type": "string", ++ "id": 2 ++ } ++ } ++ }, ++ "MembershipMetadata": { ++ "oneofs": { ++ "avatar": { ++ "oneof": [ ++ "avatarObject", ++ "avatarUri" ++ ] ++ } ++ }, ++ "fields": { ++ "name": { ++ "type": "string", ++ "id": 1 ++ }, ++ "avatarObject": { ++ "type": "uint32", ++ "id": 2 ++ }, ++ "avatarUri": { ++ "type": "string", ++ "id": 4 ++ }, ++ "about": { ++ "type": "string", ++ "id": 3 ++ }, ++ "externalResources": { ++ "rule": "repeated", ++ "type": "ExternalResource", ++ "id": 5 ++ } ++ }, ++ "nested": { ++ "ExternalResource": { ++ "fields": { ++ "type": { ++ "type": "ResourceType", ++ "id": 1 ++ }, ++ "value": { ++ "type": "string", ++ "id": 2 ++ } ++ }, ++ "nested": { ++ "ResourceType": { ++ "values": { ++ "EMAIL": 0, ++ "HYPERLINK": 1, ++ "TWITTER": 2, ++ "TELEGRAM": 3, ++ "DISCORD": 4, ++ "FACEBOOK": 5, ++ "YOUTUBE": 6, ++ "MATRIX": 7, ++ "IRC": 8, ++ "WECHAT": 9, ++ "WHATSAPP": 10 ++ } ++ } ++ } ++ } ++ } ++ }, ++ "ReactVideo": { ++ "fields": { ++ "videoId": { ++ "rule": "required", ++ "type": "uint64", ++ "id": 1 ++ }, ++ "reaction": { ++ "rule": "required", ++ "type": "Reaction", ++ "id": 2 ++ } ++ }, ++ "nested": { ++ "Reaction": { ++ "values": { ++ "LIKE": 0, ++ "UNLIKE": 1 ++ } ++ } ++ } ++ }, ++ "ReactComment": { ++ "fields": { ++ "commentId": { ++ "rule": "required", ++ "type": "string", ++ "id": 1 ++ }, ++ "reactionId": { ++ "rule": "required", ++ "type": "uint32", ++ "id": 2 ++ } ++ } ++ }, ++ "CreateComment": { ++ "fields": { ++ "videoId": { ++ "rule": "required", ++ "type": "uint64", ++ "id": 1 ++ }, ++ "parentCommentId": { ++ "type": "string", ++ "id": 2 ++ }, ++ "body": { ++ "rule": "required", ++ "type": "string", ++ "id": 3 ++ } ++ } ++ }, ++ "EditComment": { ++ "fields": { ++ "commentId": { ++ "rule": "required", ++ "type": "string", ++ "id": 1 ++ }, ++ "newBody": { ++ "rule": "required", ++ "type": "string", ++ "id": 2 ++ } ++ } ++ }, ++ "DeleteComment": { ++ "fields": { ++ "commentId": { ++ "rule": "required", ++ "type": "string", ++ "id": 1 ++ } ++ } ++ }, ++ "PinOrUnpinComment": { ++ "fields": { ++ "videoId": { ++ "rule": "required", ++ "type": "uint64", ++ "id": 1 ++ }, ++ "commentId": { ++ "rule": "required", ++ "type": "string", ++ "id": 2 ++ }, ++ "option": { ++ "rule": "required", ++ "type": "Option", ++ "id": 3 ++ } ++ }, ++ "nested": { ++ "Option": { ++ "values": { ++ "PIN": 0, ++ "UNPIN": 1 ++ } ++ } ++ } ++ }, ++ "ModerateComment": { ++ "fields": { ++ "commentId": { ++ "rule": "required", ++ "type": "string", ++ "id": 1 ++ }, ++ "rationale": { ++ "rule": "required", ++ "type": "string", ++ "id": 2 ++ } ++ } ++ }, ++ "BanOrUnbanMemberFromChannel": { ++ "fields": { ++ "memberId": { ++ "rule": "required", ++ "type": "uint64", ++ "id": 1 ++ }, ++ "option": { ++ "rule": "required", ++ "type": "Option", ++ "id": 2 ++ } ++ }, ++ "nested": { ++ "Option": { ++ "values": { ++ "BAN": 0, ++ "UNBAN": 1 ++ } ++ } ++ } ++ }, ++ "VideoReactionsPreference": { ++ "fields": { ++ "videoId": { ++ "rule": "required", ++ "type": "uint64", ++ "id": 1 ++ }, ++ "option": { ++ "rule": "required", ++ "type": "Option", ++ "id": 2 ++ } ++ }, ++ "nested": { ++ "Option": { ++ "values": { ++ "ENABLE": 0, ++ "DISABLE": 1 ++ } ++ } ++ } ++ }, ++ "CreateVideoCategory": { ++ "fields": { ++ "name": { ++ "rule": "required", ++ "type": "string", ++ "id": 1 ++ }, ++ "description": { ++ "type": "string", ++ "id": 2 ++ }, ++ "parentCategoryId": { ++ "type": "string", ++ "id": 3 ++ } ++ } ++ }, ++ "MakeChannelPayment": { ++ "oneofs": { ++ "paymentContext": { ++ "oneof": [ ++ "videoId" ++ ] ++ } ++ }, ++ "fields": { ++ "rationale": { ++ "type": "string", ++ "id": 1 ++ }, ++ "videoId": { ++ "type": "uint64", ++ "id": 2 ++ } ++ } ++ }, ++ "AppMetadata": { ++ "fields": { ++ "websiteUrl": { ++ "type": "string", ++ "id": 2 ++ }, ++ "useUri": { ++ "type": "string", ++ "id": 3 ++ }, ++ "smallIcon": { ++ "type": "string", ++ "id": 4 ++ }, ++ "mediumIcon": { ++ "type": "string", ++ "id": 5 ++ }, ++ "bigIcon": { ++ "type": "string", ++ "id": 6 ++ }, ++ "oneLiner": { ++ "type": "string", ++ "id": 7 ++ }, ++ "description": { ++ "type": "string", ++ "id": 8 ++ }, ++ "termsOfService": { ++ "type": "string", ++ "id": 9 ++ }, ++ "authKey": { ++ "type": "string", ++ "id": 10 ++ }, ++ "platforms": { ++ "rule": "repeated", ++ "type": "string", ++ "id": 11 ++ }, ++ "category": { ++ "type": "string", ++ "id": 12 ++ } ++ } ++ }, ++ "CreateApp": { ++ "fields": { ++ "name": { ++ "rule": "required", ++ "type": "string", ++ "id": 1 ++ }, ++ "appMetadata": { ++ "type": "AppMetadata", ++ "id": 2 ++ } ++ } ++ }, ++ "UpdateApp": { ++ "fields": { ++ "appId": { ++ "rule": "required", ++ "type": "string", ++ "id": 1 ++ }, ++ "appMetadata": { ++ "type": "AppMetadata", ++ "id": 2 ++ } ++ } ++ }, ++ "MemberRemarked": { ++ "oneofs": { ++ "memberRemarked": { ++ "oneof": [ ++ "reactVideo", ++ "reactComment", ++ "createComment", ++ "editComment", ++ "deleteComment", ++ "createVideoCategory", ++ "createApp", ++ "updateApp", ++ "makeChannelPayment" ++ ] ++ } ++ }, ++ "fields": { ++ "reactVideo": { ++ "type": "ReactVideo", ++ "id": 1 ++ }, ++ "reactComment": { ++ "type": "ReactComment", ++ "id": 2 ++ }, ++ "createComment": { ++ "type": "CreateComment", ++ "id": 3 ++ }, ++ "editComment": { ++ "type": "EditComment", ++ "id": 4 ++ }, ++ "deleteComment": { ++ "type": "DeleteComment", ++ "id": 5 ++ }, ++ "createVideoCategory": { ++ "type": "CreateVideoCategory", ++ "id": 6 ++ }, ++ "createApp": { ++ "type": "CreateApp", ++ "id": 7 ++ }, ++ "updateApp": { ++ "type": "UpdateApp", ++ "id": 8 ++ }, ++ "makeChannelPayment": { ++ "type": "MakeChannelPayment", ++ "id": 10 ++ } ++ } ++ }, ++ "ChannelModeratorRemarked": { ++ "oneofs": { ++ "channelModeratorRemarked": { ++ "oneof": [ ++ "moderateComment" ++ ] ++ } ++ }, ++ "fields": { ++ "moderateComment": { ++ "type": "ModerateComment", ++ "id": 1 ++ } ++ } ++ }, ++ "ChannelOwnerRemarked": { ++ "oneofs": { ++ "channelOwnerRemarked": { ++ "oneof": [ ++ "pinOrUnpinComment", ++ "banOrUnbanMemberFromChannel", ++ "videoReactionsPreference", ++ "moderateComment" ++ ] ++ } ++ }, ++ "fields": { ++ "pinOrUnpinComment": { ++ "type": "PinOrUnpinComment", ++ "id": 1 ++ }, ++ "banOrUnbanMemberFromChannel": { ++ "type": "BanOrUnbanMemberFromChannel", ++ "id": 2 ++ }, ++ "videoReactionsPreference": { ++ "type": "VideoReactionsPreference", ++ "id": 3 ++ }, ++ "moderateComment": { ++ "type": "ModerateComment", ++ "id": 5 ++ } ++ } ++ }, ++ "PersonMetadata": { ++ "fields": { ++ "firstName": { ++ "type": "string", ++ "id": 1 ++ }, ++ "middleName": { ++ "type": "string", ++ "id": 2 ++ }, ++ "lastName": { ++ "type": "string", ++ "id": 3 ++ }, ++ "about": { ++ "type": "string", ++ "id": 4 ++ }, ++ "coverPhoto": { ++ "type": "uint32", ++ "id": 5 ++ }, ++ "avatarPhoto": { ++ "type": "uint32", ++ "id": 6 ++ } ++ } ++ }, ++ "ProposalsDiscussionPostMetadata": { ++ "fields": { ++ "text": { ++ "type": "string", ++ "id": 1 ++ }, ++ "repliesTo": { ++ "type": "uint32", ++ "id": 2 ++ } ++ } ++ }, ++ "SeriesMetadata": { ++ "fields": { ++ "title": { ++ "type": "string", ++ "id": 1 ++ }, ++ "description": { ++ "type": "string", ++ "id": 2 ++ }, ++ "coverPhoto": { ++ "type": "uint32", ++ "id": 3 ++ }, ++ "persons": { ++ "rule": "repeated", ++ "type": "uint64", ++ "id": 4 ++ } ++ } ++ }, ++ "SeasonMetadata": { ++ "fields": { ++ "title": { ++ "type": "string", ++ "id": 1 ++ }, ++ "description": { ++ "type": "string", ++ "id": 2 ++ }, ++ "coverPhoto": { ++ "type": "uint32", ++ "id": 3 ++ }, ++ "persons": { ++ "rule": "repeated", ++ "type": "uint64", ++ "id": 4 ++ } ++ } ++ }, ++ "GeoCoordiantes": { ++ "fields": { ++ "latitude": { ++ "type": "float", ++ "id": 3 ++ }, ++ "longitude": { ++ "type": "float", ++ "id": 4 ++ } ++ } ++ }, ++ "NodeLocationMetadata": { ++ "fields": { ++ "countryCode": { ++ "type": "string", ++ "id": 1 ++ }, ++ "city": { ++ "type": "string", ++ "id": 2 ++ }, ++ "coordinates": { ++ "type": "GeoCoordiantes", ++ "id": 3 ++ } ++ } ++ }, ++ "StorageBucketOperatorMetadata": { ++ "fields": { ++ "endpoint": { ++ "type": "string", ++ "id": 1 ++ }, ++ "location": { ++ "type": "NodeLocationMetadata", ++ "id": 2 ++ }, ++ "extra": { ++ "type": "string", ++ "id": 3 ++ } ++ } ++ }, ++ "DistributionBucketOperatorMetadata": { ++ "fields": { ++ "endpoint": { ++ "type": "string", ++ "id": 1 ++ }, ++ "location": { ++ "type": "NodeLocationMetadata", ++ "id": 2 ++ }, ++ "extra": { ++ "type": "string", ++ "id": 3 ++ } ++ } ++ }, ++ "GeographicalArea": { ++ "oneofs": { ++ "code": { ++ "oneof": [ ++ "continent", ++ "countryCode", ++ "subdivisionCode" ++ ] ++ } ++ }, ++ "fields": { ++ "continent": { ++ "type": "Continent", ++ "id": 1 ++ }, ++ "countryCode": { ++ "type": "string", ++ "id": 2 ++ }, ++ "subdivisionCode": { ++ "type": "string", ++ "id": 3 ++ } ++ }, ++ "nested": { ++ "Continent": { ++ "values": { ++ "AF": 1, ++ "NA": 2, ++ "OC": 3, ++ "AN": 4, ++ "AS": 5, ++ "EU": 6, ++ "SA": 7 ++ } ++ } ++ } ++ }, ++ "DistributionBucketFamilyMetadata": { ++ "fields": { ++ "region": { ++ "type": "string", ++ "id": 1 ++ }, ++ "description": { ++ "type": "string", ++ "id": 2 ++ }, ++ "areas": { ++ "rule": "repeated", ++ "type": "GeographicalArea", ++ "id": 3 ++ }, ++ "latencyTestTargets": { ++ "rule": "repeated", ++ "type": "string", ++ "id": 4 ++ } ++ } ++ }, ++ "CreatorTokenIssuerRemarked": { ++ "oneofs": { ++ "creatorTokenIssuerRemarked": { ++ "oneof": [ ++ "updateTokenMetadata" ++ ] ++ } ++ }, ++ "fields": { ++ "updateTokenMetadata": { ++ "type": "UpdateTokenMetadata", ++ "id": 1 ++ } ++ } ++ }, ++ "UpdateTokenMetadata": { ++ "fields": { ++ "newMetadata": { ++ "type": "TokenMetadata", ++ "id": 1 ++ } ++ } ++ }, ++ "TokenMetadata": { ++ "oneofs": { ++ "avatar": { ++ "oneof": [ ++ "avatarObject", ++ "avatarUri" ++ ] ++ } ++ }, ++ "fields": { ++ "name": { ++ "type": "string", ++ "id": 1 ++ }, ++ "description": { ++ "type": "string", ++ "id": 2 ++ }, ++ "avatarObject": { ++ "type": "uint32", ++ "id": 3 ++ }, ++ "avatarUri": { ++ "type": "string", ++ "id": 4 ++ }, ++ "benefits": { ++ "rule": "repeated", ++ "type": "Benefit", ++ "id": 5 ++ }, ++ "whitelistApplicationNote": { ++ "type": "string", ++ "id": 6 ++ }, ++ "whitelistApplicationApplyLink": { ++ "type": "string", ++ "id": 7 ++ }, ++ "trailerVideoId": { ++ "type": "uint64", ++ "id": 8 ++ } ++ } ++ }, ++ "Benefit": { ++ "fields": { ++ "title": { ++ "type": "string", ++ "id": 1 ++ }, ++ "description": { ++ "type": "string", ++ "id": 2 ++ }, ++ "emoji": { ++ "type": "string", ++ "id": 3 ++ }, ++ "displayOrder": { ++ "type": "uint32", ++ "id": 4 ++ } ++ } ++ }, ++ "SaleMetadata": { ++ "fields": { ++ "termsAndConditions": { ++ "type": "string", ++ "id": 1 ++ } ++ } ++ }, ++ "PublishedBeforeJoystream": { ++ "fields": { ++ "isPublished": { ++ "type": "bool", ++ "id": 1 ++ }, ++ "date": { ++ "type": "string", ++ "id": 2 ++ } ++ } ++ }, ++ "License": { ++ "fields": { ++ "code": { ++ "type": "uint32", ++ "id": 1 ++ }, ++ "attribution": { ++ "type": "string", ++ "id": 2 ++ }, ++ "customText": { ++ "type": "string", ++ "id": 3 ++ } ++ } ++ }, ++ "MediaType": { ++ "fields": { ++ "codecName": { ++ "type": "string", ++ "id": 1 ++ }, ++ "container": { ++ "type": "string", ++ "id": 2 ++ }, ++ "mimeMediaType": { ++ "type": "string", ++ "id": 3 ++ } ++ } ++ }, ++ "SubtitleMetadata": { ++ "fields": { ++ "type": { ++ "rule": "required", ++ "type": "string", ++ "id": 1 ++ }, ++ "newAsset": { ++ "type": "uint32", ++ "id": 2 ++ }, ++ "language": { ++ "rule": "required", ++ "type": "string", ++ "id": 3 ++ }, ++ "mimeType": { ++ "rule": "required", ++ "type": "string", ++ "id": 4 ++ } ++ } ++ }, ++ "VideoMetadata": { ++ "fields": { ++ "title": { ++ "type": "string", ++ "id": 1 ++ }, ++ "description": { ++ "type": "string", ++ "id": 2 ++ }, ++ "video": { ++ "type": "uint32", ++ "id": 3 ++ }, ++ "thumbnailPhoto": { ++ "type": "uint32", ++ "id": 4 ++ }, ++ "duration": { ++ "type": "uint32", ++ "id": 5 ++ }, ++ "mediaPixelHeight": { ++ "type": "uint32", ++ "id": 6 ++ }, ++ "mediaPixelWidth": { ++ "type": "uint32", ++ "id": 7 ++ }, ++ "mediaType": { ++ "type": "MediaType", ++ "id": 8 ++ }, ++ "language": { ++ "type": "string", ++ "id": 9 ++ }, ++ "license": { ++ "type": "License", ++ "id": 10 ++ }, ++ "publishedBeforeJoystream": { ++ "type": "PublishedBeforeJoystream", ++ "id": 11 ++ }, ++ "hasMarketing": { ++ "type": "bool", ++ "id": 12 ++ }, ++ "isPublic": { ++ "type": "bool", ++ "id": 13 ++ }, ++ "isExplicit": { ++ "type": "bool", ++ "id": 14 ++ }, ++ "persons": { ++ "rule": "repeated", ++ "type": "uint64", ++ "id": 15 ++ }, ++ "category": { ++ "type": "string", ++ "id": 16 ++ }, ++ "subtitles": { ++ "rule": "repeated", ++ "type": "SubtitleMetadata", ++ "id": 17 ++ }, ++ "enableComments": { ++ "type": "bool", ++ "id": 18 ++ }, ++ "clearSubtitles": { ++ "type": "bool", ++ "id": 19 ++ } ++ } ++ }, ++ "ContentMetadata": { ++ "oneofs": { ++ "contentMetadata": { ++ "oneof": [ ++ "videoMetadata" ++ ] ++ } ++ }, ++ "fields": { ++ "videoMetadata": { ++ "type": "VideoMetadata", ++ "id": 1 ++ } ++ } ++ }, ++ "OpeningMetadata": { ++ "fields": { ++ "shortDescription": { ++ "type": "string", ++ "id": 1 ++ }, ++ "description": { ++ "type": "string", ++ "id": 2 ++ }, ++ "hiringLimit": { ++ "type": "uint32", ++ "id": 3 ++ }, ++ "expectedEndingTimestamp": { ++ "type": "uint32", ++ "id": 4 ++ }, ++ "applicationDetails": { ++ "type": "string", ++ "id": 5 ++ }, ++ "applicationFormQuestions": { ++ "rule": "repeated", ++ "type": "ApplicationFormQuestion", ++ "id": 6 ++ }, ++ "title": { ++ "type": "string", ++ "id": 7 ++ } ++ }, ++ "nested": { ++ "ApplicationFormQuestion": { ++ "fields": { ++ "question": { ++ "type": "string", ++ "id": 1 ++ }, ++ "type": { ++ "type": "InputType", ++ "id": 2 ++ } ++ }, ++ "nested": { ++ "InputType": { ++ "values": { ++ "TEXTAREA": 0, ++ "TEXT": 1 ++ } ++ } ++ } ++ } ++ } ++ }, ++ "UpcomingOpeningMetadata": { ++ "fields": { ++ "expectedStart": { ++ "type": "uint32", ++ "id": 1 ++ }, ++ "rewardPerBlock": { ++ "type": "uint64", ++ "id": 2 ++ }, ++ "minApplicationStake": { ++ "type": "uint64", ++ "id": 3 ++ }, ++ "metadata": { ++ "type": "OpeningMetadata", ++ "id": 4 ++ } ++ } ++ }, ++ "ApplicationMetadata": { ++ "fields": { ++ "answers": { ++ "rule": "repeated", ++ "type": "string", ++ "id": 1 ++ } ++ } ++ }, ++ "WorkingGroupMetadata": { ++ "fields": { ++ "description": { ++ "type": "string", ++ "id": 1 ++ }, ++ "about": { ++ "type": "string", ++ "id": 2 ++ }, ++ "status": { ++ "type": "string", ++ "id": 3 ++ }, ++ "statusMessage": { ++ "type": "string", ++ "id": 4 ++ } ++ } ++ }, ++ "SetGroupMetadata": { ++ "fields": { ++ "newMetadata": { ++ "type": "WorkingGroupMetadata", ++ "id": 1 ++ } ++ } ++ }, ++ "AddUpcomingOpening": { ++ "fields": { ++ "metadata": { ++ "type": "UpcomingOpeningMetadata", ++ "id": 1 ++ } ++ } ++ }, ++ "RemoveUpcomingOpening": { ++ "fields": { ++ "id": { ++ "type": "string", ++ "id": 1 ++ } ++ } ++ }, ++ "WorkingGroupMetadataAction": { ++ "oneofs": { ++ "action": { ++ "oneof": [ ++ "setGroupMetadata", ++ "addUpcomingOpening", ++ "removeUpcomingOpening" ++ ] ++ } ++ }, ++ "fields": { ++ "setGroupMetadata": { ++ "type": "SetGroupMetadata", ++ "id": 1 ++ }, ++ "addUpcomingOpening": { ++ "type": "AddUpcomingOpening", ++ "id": 2 ++ }, ++ "removeUpcomingOpening": { ++ "type": "RemoveUpcomingOpening", ++ "id": 3 ++ } ++ } ++ }, ++ "ModeratePost": { ++ "fields": { ++ "postId": { ++ "rule": "required", ++ "type": "uint64", ++ "id": 1 ++ }, ++ "rationale": { ++ "rule": "required", ++ "type": "string", ++ "id": 2 ++ } ++ } ++ }, ++ "RemarkMetadataAction": { ++ "oneofs": { ++ "action": { ++ "oneof": [ ++ "moderatePost" ++ ] ++ } ++ }, ++ "fields": { ++ "moderatePost": { ++ "type": "ModeratePost", ++ "id": 1 ++ } ++ } ++ } ++ } ++} +diff --git a/node_modules/@joystream/metadata-protobuf/lib/types.d.ts b/node_modules/@joystream/metadata-protobuf/lib/types.d.ts +index 79612c9..dd7db96 100644 +--- a/node_modules/@joystream/metadata-protobuf/lib/types.d.ts ++++ b/node_modules/@joystream/metadata-protobuf/lib/types.d.ts +@@ -4,6 +4,7 @@ export declare type AnyMessage = T & { + toJSON(): Record; + }; + export declare type AnyMetadataClass = { ++ new (): T; + name: string; + decode(binary: Uint8Array): AnyMessage; + encode(obj: T): { +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/.eslintignore b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/.eslintignore +new file mode 100644 +index 0000000..d0049b1 +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/.eslintignore +@@ -0,0 +1,4 @@ ++lib/ ++proto/ ++compiled/ ++.eslintrc.js +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/.eslintrc.js b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/.eslintrc.js +new file mode 100644 +index 0000000..d8ea276 +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/.eslintrc.js +@@ -0,0 +1,16 @@ ++module.exports = { ++ env: { ++ mocha: true, ++ }, ++ parserOptions: { ++ project: './tsconfig.json' ++ }, ++ extends: [ ++ '@joystream/eslint-config' ++ ], ++ rules: { ++ 'no-unused-vars': 'off', // Required by the typescript rule below ++ '@typescript-eslint/no-unused-vars': ['error'], ++ '@typescript-eslint/no-floating-promises': 'error', ++ }, ++} +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/.gitignore b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/.gitignore +new file mode 100644 +index 0000000..1789b65 +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/.gitignore +@@ -0,0 +1,4 @@ ++node_modules/ ++lib/ ++compiled/ ++src/json/*.json +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/.prettierignore b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/.prettierignore +new file mode 100644 +index 0000000..79fafec +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/.prettierignore +@@ -0,0 +1,5 @@ ++lib/ ++doc/ ++proto/ ++compiled/ ++src/json/messages.json +\ No newline at end of file +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/README.md b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/README.md +new file mode 100644 +index 0000000..af33fc3 +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/README.md +@@ -0,0 +1,51 @@ ++## Joystream Metadata Library ++ ++This package contains protobuf message definitions compiled to Javascript/Typescript used for creating and updating various metadata blobs in Joystream. ++ ++### Message Specs ++ ++Documented in [doc](./doc) folder ++ ++### Choice of protobuf protocol v2 ++ ++For our usecase we wish to re-use same message to create and update subset of fields. ++For this reason we need the explicit information about wether a field has been set or not and this is only possible with proto v2. ++ ++Background: required/optional feilds are deprecated in [proto v3](https://www.ben-morris.com/handling-protocol-buffers-backwards-compatibility-between-versions-2-and-3-using-c/) ++ ++ ++### Helper methods ++The custom Joystream types such as License have helper methods to construct pre-defined well known values. ++ ++### Example code: ++ ++Best place to look at are the [tests specs](./test) ++ ++### Opaque types ++We use simple [ISO_639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) code representation for Language. ++useful npm package https://www.npmjs.com/package/iso-639-1 ++ ++### Building the package ++ ++Building will compile the protofiles using [protobufjs](https://www.npmjs.com/package/protobufjs) and build the library from source. ++ ++- pre-requisists for generating documentation: ++ - [protoc](https://github.com/protocolbuffers/protobuf/releases) ++ - [golang](https://golang.org/) ++ - [protoc-gen-doc](https://github.com/pseudomuto/protoc-gen-doc) to generate docs ++ ++``` ++yarn && yarn build ++``` ++ ++### Generating docs ++ ++``` ++yarn generate-docs ++``` ++ ++### Tests ++ ++``` ++yarn test ++``` +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/compiled/index.d.ts b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/compiled/index.d.ts +new file mode 100644 +index 0000000..055ccad +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/compiled/index.d.ts +@@ -0,0 +1,6871 @@ ++import { Long } from 'long' ++import * as $protobuf from "protobufjs"; ++/** Properties of an AppActionMetadata. */ ++export interface IAppActionMetadata { ++ ++ /** AppActionMetadata videoId */ ++ videoId?: (string|null); ++} ++ ++/** Represents an AppActionMetadata. */ ++export class AppActionMetadata implements IAppActionMetadata { ++ ++ /** ++ * Constructs a new AppActionMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IAppActionMetadata); ++ ++ /** AppActionMetadata videoId. */ ++ public videoId: string; ++ ++ /** ++ * Creates a new AppActionMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns AppActionMetadata instance ++ */ ++ public static create(properties?: IAppActionMetadata): AppActionMetadata; ++ ++ /** ++ * Encodes the specified AppActionMetadata message. Does not implicitly {@link AppActionMetadata.verify|verify} messages. ++ * @param message AppActionMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IAppActionMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified AppActionMetadata message, length delimited. Does not implicitly {@link AppActionMetadata.verify|verify} messages. ++ * @param message AppActionMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IAppActionMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes an AppActionMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns AppActionMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): AppActionMetadata; ++ ++ /** ++ * Decodes an AppActionMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns AppActionMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): AppActionMetadata; ++ ++ /** ++ * Verifies an AppActionMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates an AppActionMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns AppActionMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): AppActionMetadata; ++ ++ /** ++ * Creates a plain object from an AppActionMetadata message. Also converts values to other types if specified. ++ * @param message AppActionMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: AppActionMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this AppActionMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of an AppAction. */ ++export interface IAppAction { ++ ++ /** AppAction appId */ ++ appId: string; ++ ++ /** AppAction metadata */ ++ metadata?: (Uint8Array|null); ++ ++ /** AppAction rawAction */ ++ rawAction?: (Uint8Array|null); ++ ++ /** AppAction signature */ ++ signature?: (Uint8Array|null); ++} ++ ++/** Represents an AppAction. */ ++export class AppAction implements IAppAction { ++ ++ /** ++ * Constructs a new AppAction. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IAppAction); ++ ++ /** AppAction appId. */ ++ public appId: string; ++ ++ /** AppAction metadata. */ ++ public metadata: Uint8Array; ++ ++ /** AppAction rawAction. */ ++ public rawAction: Uint8Array; ++ ++ /** AppAction signature. */ ++ public signature: Uint8Array; ++ ++ /** ++ * Creates a new AppAction instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns AppAction instance ++ */ ++ public static create(properties?: IAppAction): AppAction; ++ ++ /** ++ * Encodes the specified AppAction message. Does not implicitly {@link AppAction.verify|verify} messages. ++ * @param message AppAction message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IAppAction, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified AppAction message, length delimited. Does not implicitly {@link AppAction.verify|verify} messages. ++ * @param message AppAction message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IAppAction, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes an AppAction message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns AppAction ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): AppAction; ++ ++ /** ++ * Decodes an AppAction message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns AppAction ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): AppAction; ++ ++ /** ++ * Verifies an AppAction message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates an AppAction message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns AppAction ++ */ ++ public static fromObject(object: { [k: string]: any }): AppAction; ++ ++ /** ++ * Creates a plain object from an AppAction message. Also converts values to other types if specified. ++ * @param message AppAction ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: AppAction, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this AppAction to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++export namespace AppAction { ++ ++ /** ActionType enum. */ ++ enum ActionType { ++ CREATE_VIDEO = 0, ++ CREATE_CHANNEL = 1 ++ } ++ ++ /** CreatorType enum. */ ++ enum CreatorType { ++ CHANNEL = 0, ++ MEMBER = 1, ++ CURATOR_GROUP = 2 ++ } ++} ++ ++/** Properties of a BountyMetadata. */ ++export interface IBountyMetadata { ++ ++ /** BountyMetadata title */ ++ title?: (string|null); ++ ++ /** BountyMetadata description */ ++ description?: (string|null); ++ ++ /** BountyMetadata discussionThread */ ++ discussionThread?: (Long|null); ++ ++ /** BountyMetadata bannerImageUri */ ++ bannerImageUri?: (string|null); ++} ++ ++/** Represents a BountyMetadata. */ ++export class BountyMetadata implements IBountyMetadata { ++ ++ /** ++ * Constructs a new BountyMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IBountyMetadata); ++ ++ /** BountyMetadata title. */ ++ public title: string; ++ ++ /** BountyMetadata description. */ ++ public description: string; ++ ++ /** BountyMetadata discussionThread. */ ++ public discussionThread: Long; ++ ++ /** BountyMetadata bannerImageUri. */ ++ public bannerImageUri: string; ++ ++ /** ++ * Creates a new BountyMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns BountyMetadata instance ++ */ ++ public static create(properties?: IBountyMetadata): BountyMetadata; ++ ++ /** ++ * Encodes the specified BountyMetadata message. Does not implicitly {@link BountyMetadata.verify|verify} messages. ++ * @param message BountyMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IBountyMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified BountyMetadata message, length delimited. Does not implicitly {@link BountyMetadata.verify|verify} messages. ++ * @param message BountyMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IBountyMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a BountyMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns BountyMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): BountyMetadata; ++ ++ /** ++ * Decodes a BountyMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns BountyMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): BountyMetadata; ++ ++ /** ++ * Verifies a BountyMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a BountyMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns BountyMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): BountyMetadata; ++ ++ /** ++ * Creates a plain object from a BountyMetadata message. Also converts values to other types if specified. ++ * @param message BountyMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: BountyMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this BountyMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a BountyWorkData. */ ++export interface IBountyWorkData { ++ ++ /** BountyWorkData title */ ++ title?: (string|null); ++ ++ /** BountyWorkData description */ ++ description?: (string|null); ++} ++ ++/** Represents a BountyWorkData. */ ++export class BountyWorkData implements IBountyWorkData { ++ ++ /** ++ * Constructs a new BountyWorkData. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IBountyWorkData); ++ ++ /** BountyWorkData title. */ ++ public title: string; ++ ++ /** BountyWorkData description. */ ++ public description: string; ++ ++ /** ++ * Creates a new BountyWorkData instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns BountyWorkData instance ++ */ ++ public static create(properties?: IBountyWorkData): BountyWorkData; ++ ++ /** ++ * Encodes the specified BountyWorkData message. Does not implicitly {@link BountyWorkData.verify|verify} messages. ++ * @param message BountyWorkData message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IBountyWorkData, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified BountyWorkData message, length delimited. Does not implicitly {@link BountyWorkData.verify|verify} messages. ++ * @param message BountyWorkData message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IBountyWorkData, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a BountyWorkData message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns BountyWorkData ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): BountyWorkData; ++ ++ /** ++ * Decodes a BountyWorkData message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns BountyWorkData ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): BountyWorkData; ++ ++ /** ++ * Verifies a BountyWorkData message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a BountyWorkData message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns BountyWorkData ++ */ ++ public static fromObject(object: { [k: string]: any }): BountyWorkData; ++ ++ /** ++ * Creates a plain object from a BountyWorkData message. Also converts values to other types if specified. ++ * @param message BountyWorkData ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: BountyWorkData, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this BountyWorkData to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a ChannelMetadata. */ ++export interface IChannelMetadata { ++ ++ /** ChannelMetadata title */ ++ title?: (string|null); ++ ++ /** ChannelMetadata description */ ++ description?: (string|null); ++ ++ /** ChannelMetadata isPublic */ ++ isPublic?: (boolean|null); ++ ++ /** ChannelMetadata language */ ++ language?: (string|null); ++ ++ /** ChannelMetadata coverPhoto */ ++ coverPhoto?: (number|null); ++ ++ /** ChannelMetadata avatarPhoto */ ++ avatarPhoto?: (number|null); ++} ++ ++/** Represents a ChannelMetadata. */ ++export class ChannelMetadata implements IChannelMetadata { ++ ++ /** ++ * Constructs a new ChannelMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IChannelMetadata); ++ ++ /** ChannelMetadata title. */ ++ public title: string; ++ ++ /** ChannelMetadata description. */ ++ public description: string; ++ ++ /** ChannelMetadata isPublic. */ ++ public isPublic: boolean; ++ ++ /** ChannelMetadata language. */ ++ public language: string; ++ ++ /** ChannelMetadata coverPhoto. */ ++ public coverPhoto: number; ++ ++ /** ChannelMetadata avatarPhoto. */ ++ public avatarPhoto: number; ++ ++ /** ++ * Creates a new ChannelMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns ChannelMetadata instance ++ */ ++ public static create(properties?: IChannelMetadata): ChannelMetadata; ++ ++ /** ++ * Encodes the specified ChannelMetadata message. Does not implicitly {@link ChannelMetadata.verify|verify} messages. ++ * @param message ChannelMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IChannelMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified ChannelMetadata message, length delimited. Does not implicitly {@link ChannelMetadata.verify|verify} messages. ++ * @param message ChannelMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IChannelMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a ChannelMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns ChannelMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): ChannelMetadata; ++ ++ /** ++ * Decodes a ChannelMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns ChannelMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): ChannelMetadata; ++ ++ /** ++ * Verifies a ChannelMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a ChannelMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns ChannelMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): ChannelMetadata; ++ ++ /** ++ * Creates a plain object from a ChannelMetadata message. Also converts values to other types if specified. ++ * @param message ChannelMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: ChannelMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this ChannelMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a ChannelPayoutsMetadata. */ ++export interface IChannelPayoutsMetadata { ++ ++ /** ChannelPayoutsMetadata header */ ++ header: ChannelPayoutsMetadata.IHeader; ++ ++ /** ChannelPayoutsMetadata body */ ++ body: ChannelPayoutsMetadata.IBody; ++} ++ ++/** Represents a ChannelPayoutsMetadata. */ ++export class ChannelPayoutsMetadata implements IChannelPayoutsMetadata { ++ ++ /** ++ * Constructs a new ChannelPayoutsMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IChannelPayoutsMetadata); ++ ++ /** ChannelPayoutsMetadata header. */ ++ public header: ChannelPayoutsMetadata.IHeader; ++ ++ /** ChannelPayoutsMetadata body. */ ++ public body: ChannelPayoutsMetadata.IBody; ++ ++ /** ++ * Creates a new ChannelPayoutsMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns ChannelPayoutsMetadata instance ++ */ ++ public static create(properties?: IChannelPayoutsMetadata): ChannelPayoutsMetadata; ++ ++ /** ++ * Encodes the specified ChannelPayoutsMetadata message. Does not implicitly {@link ChannelPayoutsMetadata.verify|verify} messages. ++ * @param message ChannelPayoutsMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IChannelPayoutsMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified ChannelPayoutsMetadata message, length delimited. Does not implicitly {@link ChannelPayoutsMetadata.verify|verify} messages. ++ * @param message ChannelPayoutsMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IChannelPayoutsMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a ChannelPayoutsMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns ChannelPayoutsMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): ChannelPayoutsMetadata; ++ ++ /** ++ * Decodes a ChannelPayoutsMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns ChannelPayoutsMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): ChannelPayoutsMetadata; ++ ++ /** ++ * Verifies a ChannelPayoutsMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a ChannelPayoutsMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns ChannelPayoutsMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): ChannelPayoutsMetadata; ++ ++ /** ++ * Creates a plain object from a ChannelPayoutsMetadata message. Also converts values to other types if specified. ++ * @param message ChannelPayoutsMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: ChannelPayoutsMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this ChannelPayoutsMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++export namespace ChannelPayoutsMetadata { ++ ++ /** Properties of a Header. */ ++ interface IHeader { ++ ++ /** Header payloadLengthInBytes */ ++ payloadLengthInBytes: Long; ++ ++ /** Header headerLengthInBytes */ ++ headerLengthInBytes: Long; ++ ++ /** Header numberOfChannels */ ++ numberOfChannels: number; ++ ++ /** Header channelPayoutByteOffsets */ ++ channelPayoutByteOffsets?: (ChannelPayoutsMetadata.Header.IChannelPayoutByteOffset[]|null); ++ } ++ ++ /** ++ * Fields in the payload header are encoded in fixed length 32/64 bits instead of [varint encoding](https://developers.google.com/protocol-buffers/docs/encoding#varints) (uint64/32). ++ * This allows first calculating, and then setting the byte offset of each `ChannelPayoutProof` accurately, e.g. ++ * `byte_offset` = `size(Header)` + `position_where_record_for_channel_exists_in_Body` ++ * If varint encoding is used for header fields, then calculating the byte offset of `ChannelPayoutProof` ++ * w.r.t the start of the payload would be improbable since the header size won't be known. ++ */ ++ class Header implements IHeader { ++ ++ /** ++ * Constructs a new Header. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: ChannelPayoutsMetadata.IHeader); ++ ++ /** Header payloadLengthInBytes. */ ++ public payloadLengthInBytes: Long; ++ ++ /** Header headerLengthInBytes. */ ++ public headerLengthInBytes: Long; ++ ++ /** Header numberOfChannels. */ ++ public numberOfChannels: number; ++ ++ /** Header channelPayoutByteOffsets. */ ++ public channelPayoutByteOffsets: ChannelPayoutsMetadata.Header.IChannelPayoutByteOffset[]; ++ ++ /** ++ * Creates a new Header instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns Header instance ++ */ ++ public static create(properties?: ChannelPayoutsMetadata.IHeader): ChannelPayoutsMetadata.Header; ++ ++ /** ++ * Encodes the specified Header message. Does not implicitly {@link ChannelPayoutsMetadata.Header.verify|verify} messages. ++ * @param message Header message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: ChannelPayoutsMetadata.IHeader, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified Header message, length delimited. Does not implicitly {@link ChannelPayoutsMetadata.Header.verify|verify} messages. ++ * @param message Header message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: ChannelPayoutsMetadata.IHeader, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a Header message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns Header ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): ChannelPayoutsMetadata.Header; ++ ++ /** ++ * Decodes a Header message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns Header ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): ChannelPayoutsMetadata.Header; ++ ++ /** ++ * Verifies a Header message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a Header message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns Header ++ */ ++ public static fromObject(object: { [k: string]: any }): ChannelPayoutsMetadata.Header; ++ ++ /** ++ * Creates a plain object from a Header message. Also converts values to other types if specified. ++ * @param message Header ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: ChannelPayoutsMetadata.Header, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this Header to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++ } ++ ++ namespace Header { ++ ++ /** Properties of a ChannelPayoutByteOffset. */ ++ interface IChannelPayoutByteOffset { ++ ++ /** ChannelPayoutByteOffset channelId */ ++ channelId: number; ++ ++ /** ChannelPayoutByteOffset byteOffset */ ++ byteOffset: Long; ++ } ++ ++ /** Represents a ChannelPayoutByteOffset. */ ++ class ChannelPayoutByteOffset implements IChannelPayoutByteOffset { ++ ++ /** ++ * Constructs a new ChannelPayoutByteOffset. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: ChannelPayoutsMetadata.Header.IChannelPayoutByteOffset); ++ ++ /** ChannelPayoutByteOffset channelId. */ ++ public channelId: number; ++ ++ /** ChannelPayoutByteOffset byteOffset. */ ++ public byteOffset: Long; ++ ++ /** ++ * Creates a new ChannelPayoutByteOffset instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns ChannelPayoutByteOffset instance ++ */ ++ public static create(properties?: ChannelPayoutsMetadata.Header.IChannelPayoutByteOffset): ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset; ++ ++ /** ++ * Encodes the specified ChannelPayoutByteOffset message. Does not implicitly {@link ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset.verify|verify} messages. ++ * @param message ChannelPayoutByteOffset message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: ChannelPayoutsMetadata.Header.IChannelPayoutByteOffset, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified ChannelPayoutByteOffset message, length delimited. Does not implicitly {@link ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset.verify|verify} messages. ++ * @param message ChannelPayoutByteOffset message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: ChannelPayoutsMetadata.Header.IChannelPayoutByteOffset, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a ChannelPayoutByteOffset message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns ChannelPayoutByteOffset ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset; ++ ++ /** ++ * Decodes a ChannelPayoutByteOffset message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns ChannelPayoutByteOffset ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset; ++ ++ /** ++ * Verifies a ChannelPayoutByteOffset message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a ChannelPayoutByteOffset message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns ChannelPayoutByteOffset ++ */ ++ public static fromObject(object: { [k: string]: any }): ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset; ++ ++ /** ++ * Creates a plain object from a ChannelPayoutByteOffset message. Also converts values to other types if specified. ++ * @param message ChannelPayoutByteOffset ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this ChannelPayoutByteOffset to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++ } ++ } ++ ++ /** Properties of a Body. */ ++ interface IBody { ++ ++ /** Body channelPayouts */ ++ channelPayouts?: (ChannelPayoutsMetadata.Body.IChannelPayoutProof[]|null); ++ } ++ ++ /** Represents a Body. */ ++ class Body implements IBody { ++ ++ /** ++ * Constructs a new Body. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: ChannelPayoutsMetadata.IBody); ++ ++ /** Body channelPayouts. */ ++ public channelPayouts: ChannelPayoutsMetadata.Body.IChannelPayoutProof[]; ++ ++ /** ++ * Creates a new Body instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns Body instance ++ */ ++ public static create(properties?: ChannelPayoutsMetadata.IBody): ChannelPayoutsMetadata.Body; ++ ++ /** ++ * Encodes the specified Body message. Does not implicitly {@link ChannelPayoutsMetadata.Body.verify|verify} messages. ++ * @param message Body message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: ChannelPayoutsMetadata.IBody, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified Body message, length delimited. Does not implicitly {@link ChannelPayoutsMetadata.Body.verify|verify} messages. ++ * @param message Body message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: ChannelPayoutsMetadata.IBody, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a Body message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns Body ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): ChannelPayoutsMetadata.Body; ++ ++ /** ++ * Decodes a Body message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns Body ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): ChannelPayoutsMetadata.Body; ++ ++ /** ++ * Verifies a Body message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a Body message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns Body ++ */ ++ public static fromObject(object: { [k: string]: any }): ChannelPayoutsMetadata.Body; ++ ++ /** ++ * Creates a plain object from a Body message. Also converts values to other types if specified. ++ * @param message Body ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: ChannelPayoutsMetadata.Body, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this Body to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++ } ++ ++ namespace Body { ++ ++ /** Properties of a ChannelPayoutProof. */ ++ interface IChannelPayoutProof { ++ ++ /** ChannelPayoutProof channelId */ ++ channelId: number; ++ ++ /** ChannelPayoutProof cumulativeRewardEarned */ ++ cumulativeRewardEarned: string; ++ ++ /** ChannelPayoutProof merkleBranch */ ++ merkleBranch?: (ChannelPayoutsMetadata.Body.ChannelPayoutProof.IProofElement[]|null); ++ ++ /** ChannelPayoutProof reason */ ++ reason: string; ++ } ++ ++ /** Represents a ChannelPayoutProof. */ ++ class ChannelPayoutProof implements IChannelPayoutProof { ++ ++ /** ++ * Constructs a new ChannelPayoutProof. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: ChannelPayoutsMetadata.Body.IChannelPayoutProof); ++ ++ /** ChannelPayoutProof channelId. */ ++ public channelId: number; ++ ++ /** ChannelPayoutProof cumulativeRewardEarned. */ ++ public cumulativeRewardEarned: string; ++ ++ /** ChannelPayoutProof merkleBranch. */ ++ public merkleBranch: ChannelPayoutsMetadata.Body.ChannelPayoutProof.IProofElement[]; ++ ++ /** ChannelPayoutProof reason. */ ++ public reason: string; ++ ++ /** ++ * Creates a new ChannelPayoutProof instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns ChannelPayoutProof instance ++ */ ++ public static create(properties?: ChannelPayoutsMetadata.Body.IChannelPayoutProof): ChannelPayoutsMetadata.Body.ChannelPayoutProof; ++ ++ /** ++ * Encodes the specified ChannelPayoutProof message. Does not implicitly {@link ChannelPayoutsMetadata.Body.ChannelPayoutProof.verify|verify} messages. ++ * @param message ChannelPayoutProof message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: ChannelPayoutsMetadata.Body.IChannelPayoutProof, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified ChannelPayoutProof message, length delimited. Does not implicitly {@link ChannelPayoutsMetadata.Body.ChannelPayoutProof.verify|verify} messages. ++ * @param message ChannelPayoutProof message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: ChannelPayoutsMetadata.Body.IChannelPayoutProof, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a ChannelPayoutProof message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns ChannelPayoutProof ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): ChannelPayoutsMetadata.Body.ChannelPayoutProof; ++ ++ /** ++ * Decodes a ChannelPayoutProof message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns ChannelPayoutProof ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): ChannelPayoutsMetadata.Body.ChannelPayoutProof; ++ ++ /** ++ * Verifies a ChannelPayoutProof message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a ChannelPayoutProof message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns ChannelPayoutProof ++ */ ++ public static fromObject(object: { [k: string]: any }): ChannelPayoutsMetadata.Body.ChannelPayoutProof; ++ ++ /** ++ * Creates a plain object from a ChannelPayoutProof message. Also converts values to other types if specified. ++ * @param message ChannelPayoutProof ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: ChannelPayoutsMetadata.Body.ChannelPayoutProof, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this ChannelPayoutProof to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++ } ++ ++ namespace ChannelPayoutProof { ++ ++ /** Side enum. */ ++ enum Side { ++ Left = 0, ++ Right = 1 ++ } ++ ++ /** Properties of a ProofElement. */ ++ interface IProofElement { ++ ++ /** ProofElement hash */ ++ hash: string; ++ ++ /** ProofElement side */ ++ side: ChannelPayoutsMetadata.Body.ChannelPayoutProof.Side; ++ } ++ ++ /** Represents a ProofElement. */ ++ class ProofElement implements IProofElement { ++ ++ /** ++ * Constructs a new ProofElement. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: ChannelPayoutsMetadata.Body.ChannelPayoutProof.IProofElement); ++ ++ /** ProofElement hash. */ ++ public hash: string; ++ ++ /** ProofElement side. */ ++ public side: ChannelPayoutsMetadata.Body.ChannelPayoutProof.Side; ++ ++ /** ++ * Creates a new ProofElement instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns ProofElement instance ++ */ ++ public static create(properties?: ChannelPayoutsMetadata.Body.ChannelPayoutProof.IProofElement): ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement; ++ ++ /** ++ * Encodes the specified ProofElement message. Does not implicitly {@link ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement.verify|verify} messages. ++ * @param message ProofElement message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: ChannelPayoutsMetadata.Body.ChannelPayoutProof.IProofElement, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified ProofElement message, length delimited. Does not implicitly {@link ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement.verify|verify} messages. ++ * @param message ProofElement message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: ChannelPayoutsMetadata.Body.ChannelPayoutProof.IProofElement, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a ProofElement message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns ProofElement ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement; ++ ++ /** ++ * Decodes a ProofElement message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns ProofElement ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement; ++ ++ /** ++ * Verifies a ProofElement message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a ProofElement message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns ProofElement ++ */ ++ public static fromObject(object: { [k: string]: any }): ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement; ++ ++ /** ++ * Creates a plain object from a ProofElement message. Also converts values to other types if specified. ++ * @param message ProofElement ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this ProofElement to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++ } ++ } ++ } ++} ++ ++/** Properties of a CouncilCandidacyNoteMetadata. */ ++export interface ICouncilCandidacyNoteMetadata { ++ ++ /** CouncilCandidacyNoteMetadata header */ ++ header?: (string|null); ++ ++ /** CouncilCandidacyNoteMetadata bulletPoints */ ++ bulletPoints?: (string[]|null); ++ ++ /** CouncilCandidacyNoteMetadata bannerImageUri */ ++ bannerImageUri?: (string|null); ++ ++ /** CouncilCandidacyNoteMetadata description */ ++ description?: (string|null); ++} ++ ++/** Represents a CouncilCandidacyNoteMetadata. */ ++export class CouncilCandidacyNoteMetadata implements ICouncilCandidacyNoteMetadata { ++ ++ /** ++ * Constructs a new CouncilCandidacyNoteMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: ICouncilCandidacyNoteMetadata); ++ ++ /** CouncilCandidacyNoteMetadata header. */ ++ public header: string; ++ ++ /** CouncilCandidacyNoteMetadata bulletPoints. */ ++ public bulletPoints: string[]; ++ ++ /** CouncilCandidacyNoteMetadata bannerImageUri. */ ++ public bannerImageUri: string; ++ ++ /** CouncilCandidacyNoteMetadata description. */ ++ public description: string; ++ ++ /** ++ * Creates a new CouncilCandidacyNoteMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns CouncilCandidacyNoteMetadata instance ++ */ ++ public static create(properties?: ICouncilCandidacyNoteMetadata): CouncilCandidacyNoteMetadata; ++ ++ /** ++ * Encodes the specified CouncilCandidacyNoteMetadata message. Does not implicitly {@link CouncilCandidacyNoteMetadata.verify|verify} messages. ++ * @param message CouncilCandidacyNoteMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: ICouncilCandidacyNoteMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified CouncilCandidacyNoteMetadata message, length delimited. Does not implicitly {@link CouncilCandidacyNoteMetadata.verify|verify} messages. ++ * @param message CouncilCandidacyNoteMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: ICouncilCandidacyNoteMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a CouncilCandidacyNoteMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns CouncilCandidacyNoteMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): CouncilCandidacyNoteMetadata; ++ ++ /** ++ * Decodes a CouncilCandidacyNoteMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns CouncilCandidacyNoteMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): CouncilCandidacyNoteMetadata; ++ ++ /** ++ * Verifies a CouncilCandidacyNoteMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a CouncilCandidacyNoteMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns CouncilCandidacyNoteMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): CouncilCandidacyNoteMetadata; ++ ++ /** ++ * Creates a plain object from a CouncilCandidacyNoteMetadata message. Also converts values to other types if specified. ++ * @param message CouncilCandidacyNoteMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: CouncilCandidacyNoteMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this CouncilCandidacyNoteMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a ForumPostMetadata. */ ++export interface IForumPostMetadata { ++ ++ /** ForumPostMetadata text */ ++ text?: (string|null); ++ ++ /** ForumPostMetadata repliesTo */ ++ repliesTo?: (number|null); ++} ++ ++/** Represents a ForumPostMetadata. */ ++export class ForumPostMetadata implements IForumPostMetadata { ++ ++ /** ++ * Constructs a new ForumPostMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IForumPostMetadata); ++ ++ /** ForumPostMetadata text. */ ++ public text: string; ++ ++ /** ForumPostMetadata repliesTo. */ ++ public repliesTo: number; ++ ++ /** ++ * Creates a new ForumPostMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns ForumPostMetadata instance ++ */ ++ public static create(properties?: IForumPostMetadata): ForumPostMetadata; ++ ++ /** ++ * Encodes the specified ForumPostMetadata message. Does not implicitly {@link ForumPostMetadata.verify|verify} messages. ++ * @param message ForumPostMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IForumPostMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified ForumPostMetadata message, length delimited. Does not implicitly {@link ForumPostMetadata.verify|verify} messages. ++ * @param message ForumPostMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IForumPostMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a ForumPostMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns ForumPostMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): ForumPostMetadata; ++ ++ /** ++ * Decodes a ForumPostMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns ForumPostMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): ForumPostMetadata; ++ ++ /** ++ * Verifies a ForumPostMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a ForumPostMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns ForumPostMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): ForumPostMetadata; ++ ++ /** ++ * Creates a plain object from a ForumPostMetadata message. Also converts values to other types if specified. ++ * @param message ForumPostMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: ForumPostMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this ForumPostMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a ForumThreadMetadata. */ ++export interface IForumThreadMetadata { ++ ++ /** ForumThreadMetadata title */ ++ title?: (string|null); ++ ++ /** ForumThreadMetadata tags */ ++ tags?: (string[]|null); ++} ++ ++/** Represents a ForumThreadMetadata. */ ++export class ForumThreadMetadata implements IForumThreadMetadata { ++ ++ /** ++ * Constructs a new ForumThreadMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IForumThreadMetadata); ++ ++ /** ForumThreadMetadata title. */ ++ public title: string; ++ ++ /** ForumThreadMetadata tags. */ ++ public tags: string[]; ++ ++ /** ++ * Creates a new ForumThreadMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns ForumThreadMetadata instance ++ */ ++ public static create(properties?: IForumThreadMetadata): ForumThreadMetadata; ++ ++ /** ++ * Encodes the specified ForumThreadMetadata message. Does not implicitly {@link ForumThreadMetadata.verify|verify} messages. ++ * @param message ForumThreadMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IForumThreadMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified ForumThreadMetadata message, length delimited. Does not implicitly {@link ForumThreadMetadata.verify|verify} messages. ++ * @param message ForumThreadMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IForumThreadMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a ForumThreadMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns ForumThreadMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): ForumThreadMetadata; ++ ++ /** ++ * Decodes a ForumThreadMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns ForumThreadMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): ForumThreadMetadata; ++ ++ /** ++ * Verifies a ForumThreadMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a ForumThreadMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns ForumThreadMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): ForumThreadMetadata; ++ ++ /** ++ * Creates a plain object from a ForumThreadMetadata message. Also converts values to other types if specified. ++ * @param message ForumThreadMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: ForumThreadMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this ForumThreadMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a MembershipMetadata. */ ++export interface IMembershipMetadata { ++ ++ /** MembershipMetadata name */ ++ name?: (string|null); ++ ++ /** MembershipMetadata avatarObject */ ++ avatarObject?: (number|null); ++ ++ /** MembershipMetadata avatarUri */ ++ avatarUri?: (string|null); ++ ++ /** MembershipMetadata about */ ++ about?: (string|null); ++ ++ /** MembershipMetadata externalResources */ ++ externalResources?: (MembershipMetadata.IExternalResource[]|null); ++} ++ ++/** Represents a MembershipMetadata. */ ++export class MembershipMetadata implements IMembershipMetadata { ++ ++ /** ++ * Constructs a new MembershipMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IMembershipMetadata); ++ ++ /** MembershipMetadata name. */ ++ public name: string; ++ ++ /** MembershipMetadata avatarObject. */ ++ public avatarObject?: (number|null); ++ ++ /** MembershipMetadata avatarUri. */ ++ public avatarUri?: (string|null); ++ ++ /** MembershipMetadata about. */ ++ public about: string; ++ ++ /** MembershipMetadata externalResources. */ ++ public externalResources: MembershipMetadata.IExternalResource[]; ++ ++ /** MembershipMetadata avatar. */ ++ public avatar?: ("avatarObject"|"avatarUri"); ++ ++ /** ++ * Creates a new MembershipMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns MembershipMetadata instance ++ */ ++ public static create(properties?: IMembershipMetadata): MembershipMetadata; ++ ++ /** ++ * Encodes the specified MembershipMetadata message. Does not implicitly {@link MembershipMetadata.verify|verify} messages. ++ * @param message MembershipMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IMembershipMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified MembershipMetadata message, length delimited. Does not implicitly {@link MembershipMetadata.verify|verify} messages. ++ * @param message MembershipMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IMembershipMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a MembershipMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns MembershipMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): MembershipMetadata; ++ ++ /** ++ * Decodes a MembershipMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns MembershipMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): MembershipMetadata; ++ ++ /** ++ * Verifies a MembershipMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a MembershipMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns MembershipMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): MembershipMetadata; ++ ++ /** ++ * Creates a plain object from a MembershipMetadata message. Also converts values to other types if specified. ++ * @param message MembershipMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: MembershipMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this MembershipMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++export namespace MembershipMetadata { ++ ++ /** Properties of an ExternalResource. */ ++ interface IExternalResource { ++ ++ /** ExternalResource type */ ++ type?: (MembershipMetadata.ExternalResource.ResourceType|null); ++ ++ /** ExternalResource value */ ++ value?: (string|null); ++ } ++ ++ /** Represents an ExternalResource. */ ++ class ExternalResource implements IExternalResource { ++ ++ /** ++ * Constructs a new ExternalResource. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: MembershipMetadata.IExternalResource); ++ ++ /** ExternalResource type. */ ++ public type: MembershipMetadata.ExternalResource.ResourceType; ++ ++ /** ExternalResource value. */ ++ public value: string; ++ ++ /** ++ * Creates a new ExternalResource instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns ExternalResource instance ++ */ ++ public static create(properties?: MembershipMetadata.IExternalResource): MembershipMetadata.ExternalResource; ++ ++ /** ++ * Encodes the specified ExternalResource message. Does not implicitly {@link MembershipMetadata.ExternalResource.verify|verify} messages. ++ * @param message ExternalResource message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: MembershipMetadata.IExternalResource, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified ExternalResource message, length delimited. Does not implicitly {@link MembershipMetadata.ExternalResource.verify|verify} messages. ++ * @param message ExternalResource message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: MembershipMetadata.IExternalResource, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes an ExternalResource message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns ExternalResource ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): MembershipMetadata.ExternalResource; ++ ++ /** ++ * Decodes an ExternalResource message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns ExternalResource ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): MembershipMetadata.ExternalResource; ++ ++ /** ++ * Verifies an ExternalResource message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates an ExternalResource message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns ExternalResource ++ */ ++ public static fromObject(object: { [k: string]: any }): MembershipMetadata.ExternalResource; ++ ++ /** ++ * Creates a plain object from an ExternalResource message. Also converts values to other types if specified. ++ * @param message ExternalResource ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: MembershipMetadata.ExternalResource, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this ExternalResource to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++ } ++ ++ namespace ExternalResource { ++ ++ /** ResourceType enum. */ ++ enum ResourceType { ++ EMAIL = 0, ++ HYPERLINK = 1, ++ TWITTER = 2, ++ TELEGRAM = 3, ++ DISCORD = 4, ++ FACEBOOK = 5, ++ YOUTUBE = 6, ++ MATRIX = 7, ++ IRC = 8, ++ WECHAT = 9, ++ WHATSAPP = 10 ++ } ++ } ++} ++ ++/** Properties of a ReactVideo. */ ++export interface IReactVideo { ++ ++ /** ReactVideo videoId */ ++ videoId: Long; ++ ++ /** ReactVideo reaction */ ++ reaction: ReactVideo.Reaction; ++} ++ ++/** Represents a ReactVideo. */ ++export class ReactVideo implements IReactVideo { ++ ++ /** ++ * Constructs a new ReactVideo. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IReactVideo); ++ ++ /** ReactVideo videoId. */ ++ public videoId: Long; ++ ++ /** ReactVideo reaction. */ ++ public reaction: ReactVideo.Reaction; ++ ++ /** ++ * Creates a new ReactVideo instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns ReactVideo instance ++ */ ++ public static create(properties?: IReactVideo): ReactVideo; ++ ++ /** ++ * Encodes the specified ReactVideo message. Does not implicitly {@link ReactVideo.verify|verify} messages. ++ * @param message ReactVideo message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IReactVideo, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified ReactVideo message, length delimited. Does not implicitly {@link ReactVideo.verify|verify} messages. ++ * @param message ReactVideo message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IReactVideo, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a ReactVideo message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns ReactVideo ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): ReactVideo; ++ ++ /** ++ * Decodes a ReactVideo message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns ReactVideo ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): ReactVideo; ++ ++ /** ++ * Verifies a ReactVideo message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a ReactVideo message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns ReactVideo ++ */ ++ public static fromObject(object: { [k: string]: any }): ReactVideo; ++ ++ /** ++ * Creates a plain object from a ReactVideo message. Also converts values to other types if specified. ++ * @param message ReactVideo ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: ReactVideo, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this ReactVideo to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++export namespace ReactVideo { ++ ++ /** Reaction enum. */ ++ enum Reaction { ++ LIKE = 0, ++ UNLIKE = 1 ++ } ++} ++ ++/** Properties of a ReactComment. */ ++export interface IReactComment { ++ ++ /** ReactComment commentId */ ++ commentId: string; ++ ++ /** ReactComment reactionId */ ++ reactionId: number; ++} ++ ++/** Represents a ReactComment. */ ++export class ReactComment implements IReactComment { ++ ++ /** ++ * Constructs a new ReactComment. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IReactComment); ++ ++ /** ReactComment commentId. */ ++ public commentId: string; ++ ++ /** ReactComment reactionId. */ ++ public reactionId: number; ++ ++ /** ++ * Creates a new ReactComment instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns ReactComment instance ++ */ ++ public static create(properties?: IReactComment): ReactComment; ++ ++ /** ++ * Encodes the specified ReactComment message. Does not implicitly {@link ReactComment.verify|verify} messages. ++ * @param message ReactComment message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IReactComment, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified ReactComment message, length delimited. Does not implicitly {@link ReactComment.verify|verify} messages. ++ * @param message ReactComment message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IReactComment, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a ReactComment message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns ReactComment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): ReactComment; ++ ++ /** ++ * Decodes a ReactComment message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns ReactComment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): ReactComment; ++ ++ /** ++ * Verifies a ReactComment message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a ReactComment message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns ReactComment ++ */ ++ public static fromObject(object: { [k: string]: any }): ReactComment; ++ ++ /** ++ * Creates a plain object from a ReactComment message. Also converts values to other types if specified. ++ * @param message ReactComment ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: ReactComment, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this ReactComment to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a CreateComment. */ ++export interface ICreateComment { ++ ++ /** CreateComment videoId */ ++ videoId: Long; ++ ++ /** CreateComment parentCommentId */ ++ parentCommentId?: (string|null); ++ ++ /** CreateComment body */ ++ body: string; ++} ++ ++/** Represents a CreateComment. */ ++export class CreateComment implements ICreateComment { ++ ++ /** ++ * Constructs a new CreateComment. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: ICreateComment); ++ ++ /** CreateComment videoId. */ ++ public videoId: Long; ++ ++ /** CreateComment parentCommentId. */ ++ public parentCommentId: string; ++ ++ /** CreateComment body. */ ++ public body: string; ++ ++ /** ++ * Creates a new CreateComment instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns CreateComment instance ++ */ ++ public static create(properties?: ICreateComment): CreateComment; ++ ++ /** ++ * Encodes the specified CreateComment message. Does not implicitly {@link CreateComment.verify|verify} messages. ++ * @param message CreateComment message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: ICreateComment, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified CreateComment message, length delimited. Does not implicitly {@link CreateComment.verify|verify} messages. ++ * @param message CreateComment message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: ICreateComment, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a CreateComment message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns CreateComment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): CreateComment; ++ ++ /** ++ * Decodes a CreateComment message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns CreateComment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): CreateComment; ++ ++ /** ++ * Verifies a CreateComment message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a CreateComment message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns CreateComment ++ */ ++ public static fromObject(object: { [k: string]: any }): CreateComment; ++ ++ /** ++ * Creates a plain object from a CreateComment message. Also converts values to other types if specified. ++ * @param message CreateComment ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: CreateComment, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this CreateComment to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of an EditComment. */ ++export interface IEditComment { ++ ++ /** EditComment commentId */ ++ commentId: string; ++ ++ /** EditComment newBody */ ++ newBody: string; ++} ++ ++/** Represents an EditComment. */ ++export class EditComment implements IEditComment { ++ ++ /** ++ * Constructs a new EditComment. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IEditComment); ++ ++ /** EditComment commentId. */ ++ public commentId: string; ++ ++ /** EditComment newBody. */ ++ public newBody: string; ++ ++ /** ++ * Creates a new EditComment instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns EditComment instance ++ */ ++ public static create(properties?: IEditComment): EditComment; ++ ++ /** ++ * Encodes the specified EditComment message. Does not implicitly {@link EditComment.verify|verify} messages. ++ * @param message EditComment message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IEditComment, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified EditComment message, length delimited. Does not implicitly {@link EditComment.verify|verify} messages. ++ * @param message EditComment message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IEditComment, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes an EditComment message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns EditComment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): EditComment; ++ ++ /** ++ * Decodes an EditComment message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns EditComment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): EditComment; ++ ++ /** ++ * Verifies an EditComment message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates an EditComment message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns EditComment ++ */ ++ public static fromObject(object: { [k: string]: any }): EditComment; ++ ++ /** ++ * Creates a plain object from an EditComment message. Also converts values to other types if specified. ++ * @param message EditComment ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: EditComment, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this EditComment to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a DeleteComment. */ ++export interface IDeleteComment { ++ ++ /** DeleteComment commentId */ ++ commentId: string; ++} ++ ++/** Represents a DeleteComment. */ ++export class DeleteComment implements IDeleteComment { ++ ++ /** ++ * Constructs a new DeleteComment. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IDeleteComment); ++ ++ /** DeleteComment commentId. */ ++ public commentId: string; ++ ++ /** ++ * Creates a new DeleteComment instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns DeleteComment instance ++ */ ++ public static create(properties?: IDeleteComment): DeleteComment; ++ ++ /** ++ * Encodes the specified DeleteComment message. Does not implicitly {@link DeleteComment.verify|verify} messages. ++ * @param message DeleteComment message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IDeleteComment, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified DeleteComment message, length delimited. Does not implicitly {@link DeleteComment.verify|verify} messages. ++ * @param message DeleteComment message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IDeleteComment, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a DeleteComment message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns DeleteComment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): DeleteComment; ++ ++ /** ++ * Decodes a DeleteComment message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns DeleteComment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): DeleteComment; ++ ++ /** ++ * Verifies a DeleteComment message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a DeleteComment message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns DeleteComment ++ */ ++ public static fromObject(object: { [k: string]: any }): DeleteComment; ++ ++ /** ++ * Creates a plain object from a DeleteComment message. Also converts values to other types if specified. ++ * @param message DeleteComment ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: DeleteComment, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this DeleteComment to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a PinOrUnpinComment. */ ++export interface IPinOrUnpinComment { ++ ++ /** PinOrUnpinComment videoId */ ++ videoId: Long; ++ ++ /** PinOrUnpinComment commentId */ ++ commentId: string; ++ ++ /** PinOrUnpinComment option */ ++ option: PinOrUnpinComment.Option; ++} ++ ++/** Represents a PinOrUnpinComment. */ ++export class PinOrUnpinComment implements IPinOrUnpinComment { ++ ++ /** ++ * Constructs a new PinOrUnpinComment. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IPinOrUnpinComment); ++ ++ /** PinOrUnpinComment videoId. */ ++ public videoId: Long; ++ ++ /** PinOrUnpinComment commentId. */ ++ public commentId: string; ++ ++ /** PinOrUnpinComment option. */ ++ public option: PinOrUnpinComment.Option; ++ ++ /** ++ * Creates a new PinOrUnpinComment instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns PinOrUnpinComment instance ++ */ ++ public static create(properties?: IPinOrUnpinComment): PinOrUnpinComment; ++ ++ /** ++ * Encodes the specified PinOrUnpinComment message. Does not implicitly {@link PinOrUnpinComment.verify|verify} messages. ++ * @param message PinOrUnpinComment message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IPinOrUnpinComment, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified PinOrUnpinComment message, length delimited. Does not implicitly {@link PinOrUnpinComment.verify|verify} messages. ++ * @param message PinOrUnpinComment message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IPinOrUnpinComment, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a PinOrUnpinComment message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns PinOrUnpinComment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): PinOrUnpinComment; ++ ++ /** ++ * Decodes a PinOrUnpinComment message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns PinOrUnpinComment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): PinOrUnpinComment; ++ ++ /** ++ * Verifies a PinOrUnpinComment message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a PinOrUnpinComment message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns PinOrUnpinComment ++ */ ++ public static fromObject(object: { [k: string]: any }): PinOrUnpinComment; ++ ++ /** ++ * Creates a plain object from a PinOrUnpinComment message. Also converts values to other types if specified. ++ * @param message PinOrUnpinComment ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: PinOrUnpinComment, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this PinOrUnpinComment to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++export namespace PinOrUnpinComment { ++ ++ /** Option enum. */ ++ enum Option { ++ PIN = 0, ++ UNPIN = 1 ++ } ++} ++ ++/** Properties of a ModerateComment. */ ++export interface IModerateComment { ++ ++ /** ModerateComment commentId */ ++ commentId: string; ++ ++ /** ModerateComment rationale */ ++ rationale: string; ++} ++ ++/** Represents a ModerateComment. */ ++export class ModerateComment implements IModerateComment { ++ ++ /** ++ * Constructs a new ModerateComment. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IModerateComment); ++ ++ /** ModerateComment commentId. */ ++ public commentId: string; ++ ++ /** ModerateComment rationale. */ ++ public rationale: string; ++ ++ /** ++ * Creates a new ModerateComment instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns ModerateComment instance ++ */ ++ public static create(properties?: IModerateComment): ModerateComment; ++ ++ /** ++ * Encodes the specified ModerateComment message. Does not implicitly {@link ModerateComment.verify|verify} messages. ++ * @param message ModerateComment message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IModerateComment, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified ModerateComment message, length delimited. Does not implicitly {@link ModerateComment.verify|verify} messages. ++ * @param message ModerateComment message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IModerateComment, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a ModerateComment message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns ModerateComment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): ModerateComment; ++ ++ /** ++ * Decodes a ModerateComment message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns ModerateComment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): ModerateComment; ++ ++ /** ++ * Verifies a ModerateComment message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a ModerateComment message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns ModerateComment ++ */ ++ public static fromObject(object: { [k: string]: any }): ModerateComment; ++ ++ /** ++ * Creates a plain object from a ModerateComment message. Also converts values to other types if specified. ++ * @param message ModerateComment ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: ModerateComment, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this ModerateComment to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a BanOrUnbanMemberFromChannel. */ ++export interface IBanOrUnbanMemberFromChannel { ++ ++ /** BanOrUnbanMemberFromChannel memberId */ ++ memberId: Long; ++ ++ /** BanOrUnbanMemberFromChannel option */ ++ option: BanOrUnbanMemberFromChannel.Option; ++} ++ ++/** Represents a BanOrUnbanMemberFromChannel. */ ++export class BanOrUnbanMemberFromChannel implements IBanOrUnbanMemberFromChannel { ++ ++ /** ++ * Constructs a new BanOrUnbanMemberFromChannel. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IBanOrUnbanMemberFromChannel); ++ ++ /** BanOrUnbanMemberFromChannel memberId. */ ++ public memberId: Long; ++ ++ /** BanOrUnbanMemberFromChannel option. */ ++ public option: BanOrUnbanMemberFromChannel.Option; ++ ++ /** ++ * Creates a new BanOrUnbanMemberFromChannel instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns BanOrUnbanMemberFromChannel instance ++ */ ++ public static create(properties?: IBanOrUnbanMemberFromChannel): BanOrUnbanMemberFromChannel; ++ ++ /** ++ * Encodes the specified BanOrUnbanMemberFromChannel message. Does not implicitly {@link BanOrUnbanMemberFromChannel.verify|verify} messages. ++ * @param message BanOrUnbanMemberFromChannel message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IBanOrUnbanMemberFromChannel, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified BanOrUnbanMemberFromChannel message, length delimited. Does not implicitly {@link BanOrUnbanMemberFromChannel.verify|verify} messages. ++ * @param message BanOrUnbanMemberFromChannel message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IBanOrUnbanMemberFromChannel, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a BanOrUnbanMemberFromChannel message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns BanOrUnbanMemberFromChannel ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): BanOrUnbanMemberFromChannel; ++ ++ /** ++ * Decodes a BanOrUnbanMemberFromChannel message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns BanOrUnbanMemberFromChannel ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): BanOrUnbanMemberFromChannel; ++ ++ /** ++ * Verifies a BanOrUnbanMemberFromChannel message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a BanOrUnbanMemberFromChannel message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns BanOrUnbanMemberFromChannel ++ */ ++ public static fromObject(object: { [k: string]: any }): BanOrUnbanMemberFromChannel; ++ ++ /** ++ * Creates a plain object from a BanOrUnbanMemberFromChannel message. Also converts values to other types if specified. ++ * @param message BanOrUnbanMemberFromChannel ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: BanOrUnbanMemberFromChannel, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this BanOrUnbanMemberFromChannel to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++export namespace BanOrUnbanMemberFromChannel { ++ ++ /** Option enum. */ ++ enum Option { ++ BAN = 0, ++ UNBAN = 1 ++ } ++} ++ ++/** Properties of a VideoReactionsPreference. */ ++export interface IVideoReactionsPreference { ++ ++ /** VideoReactionsPreference videoId */ ++ videoId: Long; ++ ++ /** VideoReactionsPreference option */ ++ option: VideoReactionsPreference.Option; ++} ++ ++/** Represents a VideoReactionsPreference. */ ++export class VideoReactionsPreference implements IVideoReactionsPreference { ++ ++ /** ++ * Constructs a new VideoReactionsPreference. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IVideoReactionsPreference); ++ ++ /** VideoReactionsPreference videoId. */ ++ public videoId: Long; ++ ++ /** VideoReactionsPreference option. */ ++ public option: VideoReactionsPreference.Option; ++ ++ /** ++ * Creates a new VideoReactionsPreference instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns VideoReactionsPreference instance ++ */ ++ public static create(properties?: IVideoReactionsPreference): VideoReactionsPreference; ++ ++ /** ++ * Encodes the specified VideoReactionsPreference message. Does not implicitly {@link VideoReactionsPreference.verify|verify} messages. ++ * @param message VideoReactionsPreference message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IVideoReactionsPreference, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified VideoReactionsPreference message, length delimited. Does not implicitly {@link VideoReactionsPreference.verify|verify} messages. ++ * @param message VideoReactionsPreference message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IVideoReactionsPreference, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a VideoReactionsPreference message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns VideoReactionsPreference ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): VideoReactionsPreference; ++ ++ /** ++ * Decodes a VideoReactionsPreference message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns VideoReactionsPreference ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): VideoReactionsPreference; ++ ++ /** ++ * Verifies a VideoReactionsPreference message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a VideoReactionsPreference message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns VideoReactionsPreference ++ */ ++ public static fromObject(object: { [k: string]: any }): VideoReactionsPreference; ++ ++ /** ++ * Creates a plain object from a VideoReactionsPreference message. Also converts values to other types if specified. ++ * @param message VideoReactionsPreference ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: VideoReactionsPreference, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this VideoReactionsPreference to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++export namespace VideoReactionsPreference { ++ ++ /** Option enum. */ ++ enum Option { ++ ENABLE = 0, ++ DISABLE = 1 ++ } ++} ++ ++/** Properties of a CreateVideoCategory. */ ++export interface ICreateVideoCategory { ++ ++ /** CreateVideoCategory name */ ++ name: string; ++ ++ /** CreateVideoCategory description */ ++ description?: (string|null); ++ ++ /** CreateVideoCategory parentCategoryId */ ++ parentCategoryId?: (string|null); ++} ++ ++/** Represents a CreateVideoCategory. */ ++export class CreateVideoCategory implements ICreateVideoCategory { ++ ++ /** ++ * Constructs a new CreateVideoCategory. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: ICreateVideoCategory); ++ ++ /** CreateVideoCategory name. */ ++ public name: string; ++ ++ /** CreateVideoCategory description. */ ++ public description: string; ++ ++ /** CreateVideoCategory parentCategoryId. */ ++ public parentCategoryId: string; ++ ++ /** ++ * Creates a new CreateVideoCategory instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns CreateVideoCategory instance ++ */ ++ public static create(properties?: ICreateVideoCategory): CreateVideoCategory; ++ ++ /** ++ * Encodes the specified CreateVideoCategory message. Does not implicitly {@link CreateVideoCategory.verify|verify} messages. ++ * @param message CreateVideoCategory message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: ICreateVideoCategory, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified CreateVideoCategory message, length delimited. Does not implicitly {@link CreateVideoCategory.verify|verify} messages. ++ * @param message CreateVideoCategory message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: ICreateVideoCategory, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a CreateVideoCategory message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns CreateVideoCategory ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): CreateVideoCategory; ++ ++ /** ++ * Decodes a CreateVideoCategory message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns CreateVideoCategory ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): CreateVideoCategory; ++ ++ /** ++ * Verifies a CreateVideoCategory message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a CreateVideoCategory message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns CreateVideoCategory ++ */ ++ public static fromObject(object: { [k: string]: any }): CreateVideoCategory; ++ ++ /** ++ * Creates a plain object from a CreateVideoCategory message. Also converts values to other types if specified. ++ * @param message CreateVideoCategory ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: CreateVideoCategory, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this CreateVideoCategory to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a MakeChannelPayment. */ ++export interface IMakeChannelPayment { ++ ++ /** MakeChannelPayment rationale */ ++ rationale?: (string|null); ++ ++ /** MakeChannelPayment videoId */ ++ videoId?: (Long|null); ++} ++ ++/** Represents a MakeChannelPayment. */ ++export class MakeChannelPayment implements IMakeChannelPayment { ++ ++ /** ++ * Constructs a new MakeChannelPayment. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IMakeChannelPayment); ++ ++ /** MakeChannelPayment rationale. */ ++ public rationale: string; ++ ++ /** MakeChannelPayment videoId. */ ++ public videoId?: (Long|null); ++ ++ /** MakeChannelPayment paymentContext. */ ++ public paymentContext?: "videoId"; ++ ++ /** ++ * Creates a new MakeChannelPayment instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns MakeChannelPayment instance ++ */ ++ public static create(properties?: IMakeChannelPayment): MakeChannelPayment; ++ ++ /** ++ * Encodes the specified MakeChannelPayment message. Does not implicitly {@link MakeChannelPayment.verify|verify} messages. ++ * @param message MakeChannelPayment message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IMakeChannelPayment, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified MakeChannelPayment message, length delimited. Does not implicitly {@link MakeChannelPayment.verify|verify} messages. ++ * @param message MakeChannelPayment message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IMakeChannelPayment, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a MakeChannelPayment message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns MakeChannelPayment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): MakeChannelPayment; ++ ++ /** ++ * Decodes a MakeChannelPayment message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns MakeChannelPayment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): MakeChannelPayment; ++ ++ /** ++ * Verifies a MakeChannelPayment message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a MakeChannelPayment message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns MakeChannelPayment ++ */ ++ public static fromObject(object: { [k: string]: any }): MakeChannelPayment; ++ ++ /** ++ * Creates a plain object from a MakeChannelPayment message. Also converts values to other types if specified. ++ * @param message MakeChannelPayment ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: MakeChannelPayment, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this MakeChannelPayment to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of an AppMetadata. */ ++export interface IAppMetadata { ++ ++ /** AppMetadata websiteUrl */ ++ websiteUrl?: (string|null); ++ ++ /** AppMetadata useUri */ ++ useUri?: (string|null); ++ ++ /** AppMetadata smallIcon */ ++ smallIcon?: (string|null); ++ ++ /** AppMetadata mediumIcon */ ++ mediumIcon?: (string|null); ++ ++ /** AppMetadata bigIcon */ ++ bigIcon?: (string|null); ++ ++ /** AppMetadata oneLiner */ ++ oneLiner?: (string|null); ++ ++ /** AppMetadata description */ ++ description?: (string|null); ++ ++ /** AppMetadata termsOfService */ ++ termsOfService?: (string|null); ++ ++ /** AppMetadata authKey */ ++ authKey?: (string|null); ++ ++ /** AppMetadata platforms */ ++ platforms?: (string[]|null); ++ ++ /** AppMetadata category */ ++ category?: (string|null); ++} ++ ++/** Represents an AppMetadata. */ ++export class AppMetadata implements IAppMetadata { ++ ++ /** ++ * Constructs a new AppMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IAppMetadata); ++ ++ /** AppMetadata websiteUrl. */ ++ public websiteUrl: string; ++ ++ /** AppMetadata useUri. */ ++ public useUri: string; ++ ++ /** AppMetadata smallIcon. */ ++ public smallIcon: string; ++ ++ /** AppMetadata mediumIcon. */ ++ public mediumIcon: string; ++ ++ /** AppMetadata bigIcon. */ ++ public bigIcon: string; ++ ++ /** AppMetadata oneLiner. */ ++ public oneLiner: string; ++ ++ /** AppMetadata description. */ ++ public description: string; ++ ++ /** AppMetadata termsOfService. */ ++ public termsOfService: string; ++ ++ /** AppMetadata authKey. */ ++ public authKey: string; ++ ++ /** AppMetadata platforms. */ ++ public platforms: string[]; ++ ++ /** AppMetadata category. */ ++ public category: string; ++ ++ /** ++ * Creates a new AppMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns AppMetadata instance ++ */ ++ public static create(properties?: IAppMetadata): AppMetadata; ++ ++ /** ++ * Encodes the specified AppMetadata message. Does not implicitly {@link AppMetadata.verify|verify} messages. ++ * @param message AppMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IAppMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified AppMetadata message, length delimited. Does not implicitly {@link AppMetadata.verify|verify} messages. ++ * @param message AppMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IAppMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes an AppMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns AppMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): AppMetadata; ++ ++ /** ++ * Decodes an AppMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns AppMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): AppMetadata; ++ ++ /** ++ * Verifies an AppMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates an AppMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns AppMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): AppMetadata; ++ ++ /** ++ * Creates a plain object from an AppMetadata message. Also converts values to other types if specified. ++ * @param message AppMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: AppMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this AppMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a CreateApp. */ ++export interface ICreateApp { ++ ++ /** CreateApp name */ ++ name: string; ++ ++ /** CreateApp appMetadata */ ++ appMetadata?: (IAppMetadata|null); ++} ++ ++/** Represents a CreateApp. */ ++export class CreateApp implements ICreateApp { ++ ++ /** ++ * Constructs a new CreateApp. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: ICreateApp); ++ ++ /** CreateApp name. */ ++ public name: string; ++ ++ /** CreateApp appMetadata. */ ++ public appMetadata?: (IAppMetadata|null); ++ ++ /** ++ * Creates a new CreateApp instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns CreateApp instance ++ */ ++ public static create(properties?: ICreateApp): CreateApp; ++ ++ /** ++ * Encodes the specified CreateApp message. Does not implicitly {@link CreateApp.verify|verify} messages. ++ * @param message CreateApp message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: ICreateApp, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified CreateApp message, length delimited. Does not implicitly {@link CreateApp.verify|verify} messages. ++ * @param message CreateApp message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: ICreateApp, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a CreateApp message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns CreateApp ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): CreateApp; ++ ++ /** ++ * Decodes a CreateApp message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns CreateApp ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): CreateApp; ++ ++ /** ++ * Verifies a CreateApp message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a CreateApp message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns CreateApp ++ */ ++ public static fromObject(object: { [k: string]: any }): CreateApp; ++ ++ /** ++ * Creates a plain object from a CreateApp message. Also converts values to other types if specified. ++ * @param message CreateApp ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: CreateApp, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this CreateApp to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of an UpdateApp. */ ++export interface IUpdateApp { ++ ++ /** UpdateApp appId */ ++ appId: string; ++ ++ /** UpdateApp appMetadata */ ++ appMetadata?: (IAppMetadata|null); ++} ++ ++/** Represents an UpdateApp. */ ++export class UpdateApp implements IUpdateApp { ++ ++ /** ++ * Constructs a new UpdateApp. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IUpdateApp); ++ ++ /** UpdateApp appId. */ ++ public appId: string; ++ ++ /** UpdateApp appMetadata. */ ++ public appMetadata?: (IAppMetadata|null); ++ ++ /** ++ * Creates a new UpdateApp instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns UpdateApp instance ++ */ ++ public static create(properties?: IUpdateApp): UpdateApp; ++ ++ /** ++ * Encodes the specified UpdateApp message. Does not implicitly {@link UpdateApp.verify|verify} messages. ++ * @param message UpdateApp message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IUpdateApp, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified UpdateApp message, length delimited. Does not implicitly {@link UpdateApp.verify|verify} messages. ++ * @param message UpdateApp message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IUpdateApp, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes an UpdateApp message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns UpdateApp ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): UpdateApp; ++ ++ /** ++ * Decodes an UpdateApp message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns UpdateApp ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): UpdateApp; ++ ++ /** ++ * Verifies an UpdateApp message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates an UpdateApp message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns UpdateApp ++ */ ++ public static fromObject(object: { [k: string]: any }): UpdateApp; ++ ++ /** ++ * Creates a plain object from an UpdateApp message. Also converts values to other types if specified. ++ * @param message UpdateApp ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: UpdateApp, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this UpdateApp to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a MemberRemarked. */ ++export interface IMemberRemarked { ++ ++ /** MemberRemarked reactVideo */ ++ reactVideo?: (IReactVideo|null); ++ ++ /** MemberRemarked reactComment */ ++ reactComment?: (IReactComment|null); ++ ++ /** MemberRemarked createComment */ ++ createComment?: (ICreateComment|null); ++ ++ /** MemberRemarked editComment */ ++ editComment?: (IEditComment|null); ++ ++ /** MemberRemarked deleteComment */ ++ deleteComment?: (IDeleteComment|null); ++ ++ /** MemberRemarked createVideoCategory */ ++ createVideoCategory?: (ICreateVideoCategory|null); ++ ++ /** MemberRemarked createApp */ ++ createApp?: (ICreateApp|null); ++ ++ /** MemberRemarked updateApp */ ++ updateApp?: (IUpdateApp|null); ++ ++ /** MemberRemarked makeChannelPayment */ ++ makeChannelPayment?: (IMakeChannelPayment|null); ++} ++ ++/** Represents a MemberRemarked. */ ++export class MemberRemarked implements IMemberRemarked { ++ ++ /** ++ * Constructs a new MemberRemarked. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IMemberRemarked); ++ ++ /** MemberRemarked reactVideo. */ ++ public reactVideo?: (IReactVideo|null); ++ ++ /** MemberRemarked reactComment. */ ++ public reactComment?: (IReactComment|null); ++ ++ /** MemberRemarked createComment. */ ++ public createComment?: (ICreateComment|null); ++ ++ /** MemberRemarked editComment. */ ++ public editComment?: (IEditComment|null); ++ ++ /** MemberRemarked deleteComment. */ ++ public deleteComment?: (IDeleteComment|null); ++ ++ /** MemberRemarked createVideoCategory. */ ++ public createVideoCategory?: (ICreateVideoCategory|null); ++ ++ /** MemberRemarked createApp. */ ++ public createApp?: (ICreateApp|null); ++ ++ /** MemberRemarked updateApp. */ ++ public updateApp?: (IUpdateApp|null); ++ ++ /** MemberRemarked makeChannelPayment. */ ++ public makeChannelPayment?: (IMakeChannelPayment|null); ++ ++ /** MemberRemarked memberRemarked. */ ++ public memberRemarked?: ("reactVideo"|"reactComment"|"createComment"|"editComment"|"deleteComment"|"createVideoCategory"|"createApp"|"updateApp"|"makeChannelPayment"); ++ ++ /** ++ * Creates a new MemberRemarked instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns MemberRemarked instance ++ */ ++ public static create(properties?: IMemberRemarked): MemberRemarked; ++ ++ /** ++ * Encodes the specified MemberRemarked message. Does not implicitly {@link MemberRemarked.verify|verify} messages. ++ * @param message MemberRemarked message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IMemberRemarked, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified MemberRemarked message, length delimited. Does not implicitly {@link MemberRemarked.verify|verify} messages. ++ * @param message MemberRemarked message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IMemberRemarked, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a MemberRemarked message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns MemberRemarked ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): MemberRemarked; ++ ++ /** ++ * Decodes a MemberRemarked message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns MemberRemarked ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): MemberRemarked; ++ ++ /** ++ * Verifies a MemberRemarked message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a MemberRemarked message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns MemberRemarked ++ */ ++ public static fromObject(object: { [k: string]: any }): MemberRemarked; ++ ++ /** ++ * Creates a plain object from a MemberRemarked message. Also converts values to other types if specified. ++ * @param message MemberRemarked ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: MemberRemarked, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this MemberRemarked to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a ChannelModeratorRemarked. */ ++export interface IChannelModeratorRemarked { ++ ++ /** ChannelModeratorRemarked moderateComment */ ++ moderateComment?: (IModerateComment|null); ++} ++ ++/** Represents a ChannelModeratorRemarked. */ ++export class ChannelModeratorRemarked implements IChannelModeratorRemarked { ++ ++ /** ++ * Constructs a new ChannelModeratorRemarked. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IChannelModeratorRemarked); ++ ++ /** ChannelModeratorRemarked moderateComment. */ ++ public moderateComment?: (IModerateComment|null); ++ ++ /** ChannelModeratorRemarked channelModeratorRemarked. */ ++ public channelModeratorRemarked?: "moderateComment"; ++ ++ /** ++ * Creates a new ChannelModeratorRemarked instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns ChannelModeratorRemarked instance ++ */ ++ public static create(properties?: IChannelModeratorRemarked): ChannelModeratorRemarked; ++ ++ /** ++ * Encodes the specified ChannelModeratorRemarked message. Does not implicitly {@link ChannelModeratorRemarked.verify|verify} messages. ++ * @param message ChannelModeratorRemarked message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IChannelModeratorRemarked, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified ChannelModeratorRemarked message, length delimited. Does not implicitly {@link ChannelModeratorRemarked.verify|verify} messages. ++ * @param message ChannelModeratorRemarked message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IChannelModeratorRemarked, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a ChannelModeratorRemarked message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns ChannelModeratorRemarked ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): ChannelModeratorRemarked; ++ ++ /** ++ * Decodes a ChannelModeratorRemarked message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns ChannelModeratorRemarked ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): ChannelModeratorRemarked; ++ ++ /** ++ * Verifies a ChannelModeratorRemarked message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a ChannelModeratorRemarked message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns ChannelModeratorRemarked ++ */ ++ public static fromObject(object: { [k: string]: any }): ChannelModeratorRemarked; ++ ++ /** ++ * Creates a plain object from a ChannelModeratorRemarked message. Also converts values to other types if specified. ++ * @param message ChannelModeratorRemarked ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: ChannelModeratorRemarked, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this ChannelModeratorRemarked to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a ChannelOwnerRemarked. */ ++export interface IChannelOwnerRemarked { ++ ++ /** ChannelOwnerRemarked pinOrUnpinComment */ ++ pinOrUnpinComment?: (IPinOrUnpinComment|null); ++ ++ /** ChannelOwnerRemarked banOrUnbanMemberFromChannel */ ++ banOrUnbanMemberFromChannel?: (IBanOrUnbanMemberFromChannel|null); ++ ++ /** ChannelOwnerRemarked videoReactionsPreference */ ++ videoReactionsPreference?: (IVideoReactionsPreference|null); ++ ++ /** ChannelOwnerRemarked moderateComment */ ++ moderateComment?: (IModerateComment|null); ++} ++ ++/** Represents a ChannelOwnerRemarked. */ ++export class ChannelOwnerRemarked implements IChannelOwnerRemarked { ++ ++ /** ++ * Constructs a new ChannelOwnerRemarked. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IChannelOwnerRemarked); ++ ++ /** ChannelOwnerRemarked pinOrUnpinComment. */ ++ public pinOrUnpinComment?: (IPinOrUnpinComment|null); ++ ++ /** ChannelOwnerRemarked banOrUnbanMemberFromChannel. */ ++ public banOrUnbanMemberFromChannel?: (IBanOrUnbanMemberFromChannel|null); ++ ++ /** ChannelOwnerRemarked videoReactionsPreference. */ ++ public videoReactionsPreference?: (IVideoReactionsPreference|null); ++ ++ /** ChannelOwnerRemarked moderateComment. */ ++ public moderateComment?: (IModerateComment|null); ++ ++ /** ChannelOwnerRemarked channelOwnerRemarked. */ ++ public channelOwnerRemarked?: ("pinOrUnpinComment"|"banOrUnbanMemberFromChannel"|"videoReactionsPreference"|"moderateComment"); ++ ++ /** ++ * Creates a new ChannelOwnerRemarked instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns ChannelOwnerRemarked instance ++ */ ++ public static create(properties?: IChannelOwnerRemarked): ChannelOwnerRemarked; ++ ++ /** ++ * Encodes the specified ChannelOwnerRemarked message. Does not implicitly {@link ChannelOwnerRemarked.verify|verify} messages. ++ * @param message ChannelOwnerRemarked message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IChannelOwnerRemarked, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified ChannelOwnerRemarked message, length delimited. Does not implicitly {@link ChannelOwnerRemarked.verify|verify} messages. ++ * @param message ChannelOwnerRemarked message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IChannelOwnerRemarked, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a ChannelOwnerRemarked message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns ChannelOwnerRemarked ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): ChannelOwnerRemarked; ++ ++ /** ++ * Decodes a ChannelOwnerRemarked message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns ChannelOwnerRemarked ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): ChannelOwnerRemarked; ++ ++ /** ++ * Verifies a ChannelOwnerRemarked message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a ChannelOwnerRemarked message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns ChannelOwnerRemarked ++ */ ++ public static fromObject(object: { [k: string]: any }): ChannelOwnerRemarked; ++ ++ /** ++ * Creates a plain object from a ChannelOwnerRemarked message. Also converts values to other types if specified. ++ * @param message ChannelOwnerRemarked ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: ChannelOwnerRemarked, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this ChannelOwnerRemarked to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a PersonMetadata. */ ++export interface IPersonMetadata { ++ ++ /** PersonMetadata firstName */ ++ firstName?: (string|null); ++ ++ /** PersonMetadata middleName */ ++ middleName?: (string|null); ++ ++ /** PersonMetadata lastName */ ++ lastName?: (string|null); ++ ++ /** PersonMetadata about */ ++ about?: (string|null); ++ ++ /** PersonMetadata coverPhoto */ ++ coverPhoto?: (number|null); ++ ++ /** PersonMetadata avatarPhoto */ ++ avatarPhoto?: (number|null); ++} ++ ++/** Represents a PersonMetadata. */ ++export class PersonMetadata implements IPersonMetadata { ++ ++ /** ++ * Constructs a new PersonMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IPersonMetadata); ++ ++ /** PersonMetadata firstName. */ ++ public firstName: string; ++ ++ /** PersonMetadata middleName. */ ++ public middleName: string; ++ ++ /** PersonMetadata lastName. */ ++ public lastName: string; ++ ++ /** PersonMetadata about. */ ++ public about: string; ++ ++ /** PersonMetadata coverPhoto. */ ++ public coverPhoto: number; ++ ++ /** PersonMetadata avatarPhoto. */ ++ public avatarPhoto: number; ++ ++ /** ++ * Creates a new PersonMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns PersonMetadata instance ++ */ ++ public static create(properties?: IPersonMetadata): PersonMetadata; ++ ++ /** ++ * Encodes the specified PersonMetadata message. Does not implicitly {@link PersonMetadata.verify|verify} messages. ++ * @param message PersonMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IPersonMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified PersonMetadata message, length delimited. Does not implicitly {@link PersonMetadata.verify|verify} messages. ++ * @param message PersonMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IPersonMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a PersonMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns PersonMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): PersonMetadata; ++ ++ /** ++ * Decodes a PersonMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns PersonMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): PersonMetadata; ++ ++ /** ++ * Verifies a PersonMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a PersonMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns PersonMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): PersonMetadata; ++ ++ /** ++ * Creates a plain object from a PersonMetadata message. Also converts values to other types if specified. ++ * @param message PersonMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: PersonMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this PersonMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a ProposalsDiscussionPostMetadata. */ ++export interface IProposalsDiscussionPostMetadata { ++ ++ /** ProposalsDiscussionPostMetadata text */ ++ text?: (string|null); ++ ++ /** ProposalsDiscussionPostMetadata repliesTo */ ++ repliesTo?: (number|null); ++} ++ ++/** Represents a ProposalsDiscussionPostMetadata. */ ++export class ProposalsDiscussionPostMetadata implements IProposalsDiscussionPostMetadata { ++ ++ /** ++ * Constructs a new ProposalsDiscussionPostMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IProposalsDiscussionPostMetadata); ++ ++ /** ProposalsDiscussionPostMetadata text. */ ++ public text: string; ++ ++ /** ProposalsDiscussionPostMetadata repliesTo. */ ++ public repliesTo: number; ++ ++ /** ++ * Creates a new ProposalsDiscussionPostMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns ProposalsDiscussionPostMetadata instance ++ */ ++ public static create(properties?: IProposalsDiscussionPostMetadata): ProposalsDiscussionPostMetadata; ++ ++ /** ++ * Encodes the specified ProposalsDiscussionPostMetadata message. Does not implicitly {@link ProposalsDiscussionPostMetadata.verify|verify} messages. ++ * @param message ProposalsDiscussionPostMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IProposalsDiscussionPostMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified ProposalsDiscussionPostMetadata message, length delimited. Does not implicitly {@link ProposalsDiscussionPostMetadata.verify|verify} messages. ++ * @param message ProposalsDiscussionPostMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IProposalsDiscussionPostMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a ProposalsDiscussionPostMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns ProposalsDiscussionPostMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): ProposalsDiscussionPostMetadata; ++ ++ /** ++ * Decodes a ProposalsDiscussionPostMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns ProposalsDiscussionPostMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): ProposalsDiscussionPostMetadata; ++ ++ /** ++ * Verifies a ProposalsDiscussionPostMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a ProposalsDiscussionPostMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns ProposalsDiscussionPostMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): ProposalsDiscussionPostMetadata; ++ ++ /** ++ * Creates a plain object from a ProposalsDiscussionPostMetadata message. Also converts values to other types if specified. ++ * @param message ProposalsDiscussionPostMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: ProposalsDiscussionPostMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this ProposalsDiscussionPostMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a SeriesMetadata. */ ++export interface ISeriesMetadata { ++ ++ /** SeriesMetadata title */ ++ title?: (string|null); ++ ++ /** SeriesMetadata description */ ++ description?: (string|null); ++ ++ /** SeriesMetadata coverPhoto */ ++ coverPhoto?: (number|null); ++ ++ /** SeriesMetadata persons */ ++ persons?: (Long[]|null); ++} ++ ++/** Represents a SeriesMetadata. */ ++export class SeriesMetadata implements ISeriesMetadata { ++ ++ /** ++ * Constructs a new SeriesMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: ISeriesMetadata); ++ ++ /** SeriesMetadata title. */ ++ public title: string; ++ ++ /** SeriesMetadata description. */ ++ public description: string; ++ ++ /** SeriesMetadata coverPhoto. */ ++ public coverPhoto: number; ++ ++ /** SeriesMetadata persons. */ ++ public persons: Long[]; ++ ++ /** ++ * Creates a new SeriesMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns SeriesMetadata instance ++ */ ++ public static create(properties?: ISeriesMetadata): SeriesMetadata; ++ ++ /** ++ * Encodes the specified SeriesMetadata message. Does not implicitly {@link SeriesMetadata.verify|verify} messages. ++ * @param message SeriesMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: ISeriesMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified SeriesMetadata message, length delimited. Does not implicitly {@link SeriesMetadata.verify|verify} messages. ++ * @param message SeriesMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: ISeriesMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a SeriesMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns SeriesMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): SeriesMetadata; ++ ++ /** ++ * Decodes a SeriesMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns SeriesMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): SeriesMetadata; ++ ++ /** ++ * Verifies a SeriesMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a SeriesMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns SeriesMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): SeriesMetadata; ++ ++ /** ++ * Creates a plain object from a SeriesMetadata message. Also converts values to other types if specified. ++ * @param message SeriesMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: SeriesMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this SeriesMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a SeasonMetadata. */ ++export interface ISeasonMetadata { ++ ++ /** SeasonMetadata title */ ++ title?: (string|null); ++ ++ /** SeasonMetadata description */ ++ description?: (string|null); ++ ++ /** SeasonMetadata coverPhoto */ ++ coverPhoto?: (number|null); ++ ++ /** SeasonMetadata persons */ ++ persons?: (Long[]|null); ++} ++ ++/** Represents a SeasonMetadata. */ ++export class SeasonMetadata implements ISeasonMetadata { ++ ++ /** ++ * Constructs a new SeasonMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: ISeasonMetadata); ++ ++ /** SeasonMetadata title. */ ++ public title: string; ++ ++ /** SeasonMetadata description. */ ++ public description: string; ++ ++ /** SeasonMetadata coverPhoto. */ ++ public coverPhoto: number; ++ ++ /** SeasonMetadata persons. */ ++ public persons: Long[]; ++ ++ /** ++ * Creates a new SeasonMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns SeasonMetadata instance ++ */ ++ public static create(properties?: ISeasonMetadata): SeasonMetadata; ++ ++ /** ++ * Encodes the specified SeasonMetadata message. Does not implicitly {@link SeasonMetadata.verify|verify} messages. ++ * @param message SeasonMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: ISeasonMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified SeasonMetadata message, length delimited. Does not implicitly {@link SeasonMetadata.verify|verify} messages. ++ * @param message SeasonMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: ISeasonMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a SeasonMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns SeasonMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): SeasonMetadata; ++ ++ /** ++ * Decodes a SeasonMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns SeasonMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): SeasonMetadata; ++ ++ /** ++ * Verifies a SeasonMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a SeasonMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns SeasonMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): SeasonMetadata; ++ ++ /** ++ * Creates a plain object from a SeasonMetadata message. Also converts values to other types if specified. ++ * @param message SeasonMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: SeasonMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this SeasonMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a GeoCoordiantes. */ ++export interface IGeoCoordiantes { ++ ++ /** GeoCoordiantes latitude */ ++ latitude?: (number|null); ++ ++ /** GeoCoordiantes longitude */ ++ longitude?: (number|null); ++} ++ ++/** Represents a GeoCoordiantes. */ ++export class GeoCoordiantes implements IGeoCoordiantes { ++ ++ /** ++ * Constructs a new GeoCoordiantes. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IGeoCoordiantes); ++ ++ /** GeoCoordiantes latitude. */ ++ public latitude: number; ++ ++ /** GeoCoordiantes longitude. */ ++ public longitude: number; ++ ++ /** ++ * Creates a new GeoCoordiantes instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns GeoCoordiantes instance ++ */ ++ public static create(properties?: IGeoCoordiantes): GeoCoordiantes; ++ ++ /** ++ * Encodes the specified GeoCoordiantes message. Does not implicitly {@link GeoCoordiantes.verify|verify} messages. ++ * @param message GeoCoordiantes message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IGeoCoordiantes, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified GeoCoordiantes message, length delimited. Does not implicitly {@link GeoCoordiantes.verify|verify} messages. ++ * @param message GeoCoordiantes message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IGeoCoordiantes, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a GeoCoordiantes message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns GeoCoordiantes ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): GeoCoordiantes; ++ ++ /** ++ * Decodes a GeoCoordiantes message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns GeoCoordiantes ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): GeoCoordiantes; ++ ++ /** ++ * Verifies a GeoCoordiantes message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a GeoCoordiantes message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns GeoCoordiantes ++ */ ++ public static fromObject(object: { [k: string]: any }): GeoCoordiantes; ++ ++ /** ++ * Creates a plain object from a GeoCoordiantes message. Also converts values to other types if specified. ++ * @param message GeoCoordiantes ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: GeoCoordiantes, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this GeoCoordiantes to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a NodeLocationMetadata. */ ++export interface INodeLocationMetadata { ++ ++ /** NodeLocationMetadata countryCode */ ++ countryCode?: (string|null); ++ ++ /** NodeLocationMetadata city */ ++ city?: (string|null); ++ ++ /** NodeLocationMetadata coordinates */ ++ coordinates?: (IGeoCoordiantes|null); ++} ++ ++/** Represents a NodeLocationMetadata. */ ++export class NodeLocationMetadata implements INodeLocationMetadata { ++ ++ /** ++ * Constructs a new NodeLocationMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: INodeLocationMetadata); ++ ++ /** NodeLocationMetadata countryCode. */ ++ public countryCode: string; ++ ++ /** NodeLocationMetadata city. */ ++ public city: string; ++ ++ /** NodeLocationMetadata coordinates. */ ++ public coordinates?: (IGeoCoordiantes|null); ++ ++ /** ++ * Creates a new NodeLocationMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns NodeLocationMetadata instance ++ */ ++ public static create(properties?: INodeLocationMetadata): NodeLocationMetadata; ++ ++ /** ++ * Encodes the specified NodeLocationMetadata message. Does not implicitly {@link NodeLocationMetadata.verify|verify} messages. ++ * @param message NodeLocationMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: INodeLocationMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified NodeLocationMetadata message, length delimited. Does not implicitly {@link NodeLocationMetadata.verify|verify} messages. ++ * @param message NodeLocationMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: INodeLocationMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a NodeLocationMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns NodeLocationMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): NodeLocationMetadata; ++ ++ /** ++ * Decodes a NodeLocationMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns NodeLocationMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): NodeLocationMetadata; ++ ++ /** ++ * Verifies a NodeLocationMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a NodeLocationMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns NodeLocationMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): NodeLocationMetadata; ++ ++ /** ++ * Creates a plain object from a NodeLocationMetadata message. Also converts values to other types if specified. ++ * @param message NodeLocationMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: NodeLocationMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this NodeLocationMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a StorageBucketOperatorMetadata. */ ++export interface IStorageBucketOperatorMetadata { ++ ++ /** StorageBucketOperatorMetadata endpoint */ ++ endpoint?: (string|null); ++ ++ /** StorageBucketOperatorMetadata location */ ++ location?: (INodeLocationMetadata|null); ++ ++ /** StorageBucketOperatorMetadata extra */ ++ extra?: (string|null); ++} ++ ++/** Represents a StorageBucketOperatorMetadata. */ ++export class StorageBucketOperatorMetadata implements IStorageBucketOperatorMetadata { ++ ++ /** ++ * Constructs a new StorageBucketOperatorMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IStorageBucketOperatorMetadata); ++ ++ /** StorageBucketOperatorMetadata endpoint. */ ++ public endpoint: string; ++ ++ /** StorageBucketOperatorMetadata location. */ ++ public location?: (INodeLocationMetadata|null); ++ ++ /** StorageBucketOperatorMetadata extra. */ ++ public extra: string; ++ ++ /** ++ * Creates a new StorageBucketOperatorMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns StorageBucketOperatorMetadata instance ++ */ ++ public static create(properties?: IStorageBucketOperatorMetadata): StorageBucketOperatorMetadata; ++ ++ /** ++ * Encodes the specified StorageBucketOperatorMetadata message. Does not implicitly {@link StorageBucketOperatorMetadata.verify|verify} messages. ++ * @param message StorageBucketOperatorMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IStorageBucketOperatorMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified StorageBucketOperatorMetadata message, length delimited. Does not implicitly {@link StorageBucketOperatorMetadata.verify|verify} messages. ++ * @param message StorageBucketOperatorMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IStorageBucketOperatorMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a StorageBucketOperatorMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns StorageBucketOperatorMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): StorageBucketOperatorMetadata; ++ ++ /** ++ * Decodes a StorageBucketOperatorMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns StorageBucketOperatorMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): StorageBucketOperatorMetadata; ++ ++ /** ++ * Verifies a StorageBucketOperatorMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a StorageBucketOperatorMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns StorageBucketOperatorMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): StorageBucketOperatorMetadata; ++ ++ /** ++ * Creates a plain object from a StorageBucketOperatorMetadata message. Also converts values to other types if specified. ++ * @param message StorageBucketOperatorMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: StorageBucketOperatorMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this StorageBucketOperatorMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a DistributionBucketOperatorMetadata. */ ++export interface IDistributionBucketOperatorMetadata { ++ ++ /** DistributionBucketOperatorMetadata endpoint */ ++ endpoint?: (string|null); ++ ++ /** DistributionBucketOperatorMetadata location */ ++ location?: (INodeLocationMetadata|null); ++ ++ /** DistributionBucketOperatorMetadata extra */ ++ extra?: (string|null); ++} ++ ++/** Represents a DistributionBucketOperatorMetadata. */ ++export class DistributionBucketOperatorMetadata implements IDistributionBucketOperatorMetadata { ++ ++ /** ++ * Constructs a new DistributionBucketOperatorMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IDistributionBucketOperatorMetadata); ++ ++ /** DistributionBucketOperatorMetadata endpoint. */ ++ public endpoint: string; ++ ++ /** DistributionBucketOperatorMetadata location. */ ++ public location?: (INodeLocationMetadata|null); ++ ++ /** DistributionBucketOperatorMetadata extra. */ ++ public extra: string; ++ ++ /** ++ * Creates a new DistributionBucketOperatorMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns DistributionBucketOperatorMetadata instance ++ */ ++ public static create(properties?: IDistributionBucketOperatorMetadata): DistributionBucketOperatorMetadata; ++ ++ /** ++ * Encodes the specified DistributionBucketOperatorMetadata message. Does not implicitly {@link DistributionBucketOperatorMetadata.verify|verify} messages. ++ * @param message DistributionBucketOperatorMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IDistributionBucketOperatorMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified DistributionBucketOperatorMetadata message, length delimited. Does not implicitly {@link DistributionBucketOperatorMetadata.verify|verify} messages. ++ * @param message DistributionBucketOperatorMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IDistributionBucketOperatorMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a DistributionBucketOperatorMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns DistributionBucketOperatorMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): DistributionBucketOperatorMetadata; ++ ++ /** ++ * Decodes a DistributionBucketOperatorMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns DistributionBucketOperatorMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): DistributionBucketOperatorMetadata; ++ ++ /** ++ * Verifies a DistributionBucketOperatorMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a DistributionBucketOperatorMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns DistributionBucketOperatorMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): DistributionBucketOperatorMetadata; ++ ++ /** ++ * Creates a plain object from a DistributionBucketOperatorMetadata message. Also converts values to other types if specified. ++ * @param message DistributionBucketOperatorMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: DistributionBucketOperatorMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this DistributionBucketOperatorMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a GeographicalArea. */ ++export interface IGeographicalArea { ++ ++ /** GeographicalArea continent */ ++ continent?: (GeographicalArea.Continent|null); ++ ++ /** GeographicalArea countryCode */ ++ countryCode?: (string|null); ++ ++ /** GeographicalArea subdivisionCode */ ++ subdivisionCode?: (string|null); ++} ++ ++/** Represents a GeographicalArea. */ ++export class GeographicalArea implements IGeographicalArea { ++ ++ /** ++ * Constructs a new GeographicalArea. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IGeographicalArea); ++ ++ /** GeographicalArea continent. */ ++ public continent?: (GeographicalArea.Continent|null); ++ ++ /** GeographicalArea countryCode. */ ++ public countryCode?: (string|null); ++ ++ /** GeographicalArea subdivisionCode. */ ++ public subdivisionCode?: (string|null); ++ ++ /** GeographicalArea code. */ ++ public code?: ("continent"|"countryCode"|"subdivisionCode"); ++ ++ /** ++ * Creates a new GeographicalArea instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns GeographicalArea instance ++ */ ++ public static create(properties?: IGeographicalArea): GeographicalArea; ++ ++ /** ++ * Encodes the specified GeographicalArea message. Does not implicitly {@link GeographicalArea.verify|verify} messages. ++ * @param message GeographicalArea message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IGeographicalArea, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified GeographicalArea message, length delimited. Does not implicitly {@link GeographicalArea.verify|verify} messages. ++ * @param message GeographicalArea message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IGeographicalArea, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a GeographicalArea message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns GeographicalArea ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): GeographicalArea; ++ ++ /** ++ * Decodes a GeographicalArea message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns GeographicalArea ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): GeographicalArea; ++ ++ /** ++ * Verifies a GeographicalArea message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a GeographicalArea message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns GeographicalArea ++ */ ++ public static fromObject(object: { [k: string]: any }): GeographicalArea; ++ ++ /** ++ * Creates a plain object from a GeographicalArea message. Also converts values to other types if specified. ++ * @param message GeographicalArea ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: GeographicalArea, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this GeographicalArea to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++export namespace GeographicalArea { ++ ++ /** Continent enum. */ ++ enum Continent { ++ AF = 1, ++ NA = 2, ++ OC = 3, ++ AN = 4, ++ AS = 5, ++ EU = 6, ++ SA = 7 ++ } ++} ++ ++/** Properties of a DistributionBucketFamilyMetadata. */ ++export interface IDistributionBucketFamilyMetadata { ++ ++ /** DistributionBucketFamilyMetadata region */ ++ region?: (string|null); ++ ++ /** DistributionBucketFamilyMetadata description */ ++ description?: (string|null); ++ ++ /** DistributionBucketFamilyMetadata areas */ ++ areas?: (IGeographicalArea[]|null); ++ ++ /** DistributionBucketFamilyMetadata latencyTestTargets */ ++ latencyTestTargets?: (string[]|null); ++} ++ ++/** Represents a DistributionBucketFamilyMetadata. */ ++export class DistributionBucketFamilyMetadata implements IDistributionBucketFamilyMetadata { ++ ++ /** ++ * Constructs a new DistributionBucketFamilyMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IDistributionBucketFamilyMetadata); ++ ++ /** DistributionBucketFamilyMetadata region. */ ++ public region: string; ++ ++ /** DistributionBucketFamilyMetadata description. */ ++ public description: string; ++ ++ /** DistributionBucketFamilyMetadata areas. */ ++ public areas: IGeographicalArea[]; ++ ++ /** DistributionBucketFamilyMetadata latencyTestTargets. */ ++ public latencyTestTargets: string[]; ++ ++ /** ++ * Creates a new DistributionBucketFamilyMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns DistributionBucketFamilyMetadata instance ++ */ ++ public static create(properties?: IDistributionBucketFamilyMetadata): DistributionBucketFamilyMetadata; ++ ++ /** ++ * Encodes the specified DistributionBucketFamilyMetadata message. Does not implicitly {@link DistributionBucketFamilyMetadata.verify|verify} messages. ++ * @param message DistributionBucketFamilyMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IDistributionBucketFamilyMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified DistributionBucketFamilyMetadata message, length delimited. Does not implicitly {@link DistributionBucketFamilyMetadata.verify|verify} messages. ++ * @param message DistributionBucketFamilyMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IDistributionBucketFamilyMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a DistributionBucketFamilyMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns DistributionBucketFamilyMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): DistributionBucketFamilyMetadata; ++ ++ /** ++ * Decodes a DistributionBucketFamilyMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns DistributionBucketFamilyMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): DistributionBucketFamilyMetadata; ++ ++ /** ++ * Verifies a DistributionBucketFamilyMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a DistributionBucketFamilyMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns DistributionBucketFamilyMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): DistributionBucketFamilyMetadata; ++ ++ /** ++ * Creates a plain object from a DistributionBucketFamilyMetadata message. Also converts values to other types if specified. ++ * @param message DistributionBucketFamilyMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: DistributionBucketFamilyMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this DistributionBucketFamilyMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a CreatorTokenIssuerRemarked. */ ++export interface ICreatorTokenIssuerRemarked { ++ ++ /** CreatorTokenIssuerRemarked updateTokenMetadata */ ++ updateTokenMetadata?: (IUpdateTokenMetadata|null); ++} ++ ++/** Represents a CreatorTokenIssuerRemarked. */ ++export class CreatorTokenIssuerRemarked implements ICreatorTokenIssuerRemarked { ++ ++ /** ++ * Constructs a new CreatorTokenIssuerRemarked. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: ICreatorTokenIssuerRemarked); ++ ++ /** CreatorTokenIssuerRemarked updateTokenMetadata. */ ++ public updateTokenMetadata?: (IUpdateTokenMetadata|null); ++ ++ /** CreatorTokenIssuerRemarked creatorTokenIssuerRemarked. */ ++ public creatorTokenIssuerRemarked?: "updateTokenMetadata"; ++ ++ /** ++ * Creates a new CreatorTokenIssuerRemarked instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns CreatorTokenIssuerRemarked instance ++ */ ++ public static create(properties?: ICreatorTokenIssuerRemarked): CreatorTokenIssuerRemarked; ++ ++ /** ++ * Encodes the specified CreatorTokenIssuerRemarked message. Does not implicitly {@link CreatorTokenIssuerRemarked.verify|verify} messages. ++ * @param message CreatorTokenIssuerRemarked message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: ICreatorTokenIssuerRemarked, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified CreatorTokenIssuerRemarked message, length delimited. Does not implicitly {@link CreatorTokenIssuerRemarked.verify|verify} messages. ++ * @param message CreatorTokenIssuerRemarked message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: ICreatorTokenIssuerRemarked, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a CreatorTokenIssuerRemarked message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns CreatorTokenIssuerRemarked ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): CreatorTokenIssuerRemarked; ++ ++ /** ++ * Decodes a CreatorTokenIssuerRemarked message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns CreatorTokenIssuerRemarked ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): CreatorTokenIssuerRemarked; ++ ++ /** ++ * Verifies a CreatorTokenIssuerRemarked message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a CreatorTokenIssuerRemarked message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns CreatorTokenIssuerRemarked ++ */ ++ public static fromObject(object: { [k: string]: any }): CreatorTokenIssuerRemarked; ++ ++ /** ++ * Creates a plain object from a CreatorTokenIssuerRemarked message. Also converts values to other types if specified. ++ * @param message CreatorTokenIssuerRemarked ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: CreatorTokenIssuerRemarked, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this CreatorTokenIssuerRemarked to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of an UpdateTokenMetadata. */ ++export interface IUpdateTokenMetadata { ++ ++ /** UpdateTokenMetadata newMetadata */ ++ newMetadata?: (ITokenMetadata|null); ++} ++ ++/** Represents an UpdateTokenMetadata. */ ++export class UpdateTokenMetadata implements IUpdateTokenMetadata { ++ ++ /** ++ * Constructs a new UpdateTokenMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IUpdateTokenMetadata); ++ ++ /** UpdateTokenMetadata newMetadata. */ ++ public newMetadata?: (ITokenMetadata|null); ++ ++ /** ++ * Creates a new UpdateTokenMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns UpdateTokenMetadata instance ++ */ ++ public static create(properties?: IUpdateTokenMetadata): UpdateTokenMetadata; ++ ++ /** ++ * Encodes the specified UpdateTokenMetadata message. Does not implicitly {@link UpdateTokenMetadata.verify|verify} messages. ++ * @param message UpdateTokenMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IUpdateTokenMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified UpdateTokenMetadata message, length delimited. Does not implicitly {@link UpdateTokenMetadata.verify|verify} messages. ++ * @param message UpdateTokenMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IUpdateTokenMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes an UpdateTokenMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns UpdateTokenMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): UpdateTokenMetadata; ++ ++ /** ++ * Decodes an UpdateTokenMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns UpdateTokenMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): UpdateTokenMetadata; ++ ++ /** ++ * Verifies an UpdateTokenMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates an UpdateTokenMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns UpdateTokenMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): UpdateTokenMetadata; ++ ++ /** ++ * Creates a plain object from an UpdateTokenMetadata message. Also converts values to other types if specified. ++ * @param message UpdateTokenMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: UpdateTokenMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this UpdateTokenMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a TokenMetadata. */ ++export interface ITokenMetadata { ++ ++ /** TokenMetadata name */ ++ name?: (string|null); ++ ++ /** TokenMetadata symbol */ ++ symbol: string; ++ ++ /** TokenMetadata description */ ++ description?: (string|null); ++ ++ /** TokenMetadata avatarObject */ ++ avatarObject?: (number|null); ++ ++ /** TokenMetadata avatarUri */ ++ avatarUri?: (string|null); ++ ++ /** TokenMetadata benefits */ ++ benefits?: (IBenefit[]|null); ++ ++ /** TokenMetadata whitelistApplicationNote */ ++ whitelistApplicationNote?: (string|null); ++ ++ /** TokenMetadata whitelistApplicationApplyLink */ ++ whitelistApplicationApplyLink?: (string|null); ++ ++ /** TokenMetadata trailerVideoId */ ++ trailerVideoId?: (Long|null); ++} ++ ++/** Represents a TokenMetadata. */ ++export class TokenMetadata implements ITokenMetadata { ++ ++ /** ++ * Constructs a new TokenMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: ITokenMetadata); ++ ++ /** TokenMetadata name. */ ++ public name: string; ++ ++ /** TokenMetadata symbol. */ ++ public symbol: string; ++ ++ /** TokenMetadata description. */ ++ public description: string; ++ ++ /** TokenMetadata avatarObject. */ ++ public avatarObject?: (number|null); ++ ++ /** TokenMetadata avatarUri. */ ++ public avatarUri?: (string|null); ++ ++ /** TokenMetadata benefits. */ ++ public benefits: IBenefit[]; ++ ++ /** TokenMetadata whitelistApplicationNote. */ ++ public whitelistApplicationNote: string; ++ ++ /** TokenMetadata whitelistApplicationApplyLink. */ ++ public whitelistApplicationApplyLink: string; ++ ++ /** TokenMetadata trailerVideoId. */ ++ public trailerVideoId: Long; ++ ++ /** TokenMetadata avatar. */ ++ public avatar?: ("avatarObject"|"avatarUri"); ++ ++ /** ++ * Creates a new TokenMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns TokenMetadata instance ++ */ ++ public static create(properties?: ITokenMetadata): TokenMetadata; ++ ++ /** ++ * Encodes the specified TokenMetadata message. Does not implicitly {@link TokenMetadata.verify|verify} messages. ++ * @param message TokenMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: ITokenMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified TokenMetadata message, length delimited. Does not implicitly {@link TokenMetadata.verify|verify} messages. ++ * @param message TokenMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: ITokenMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a TokenMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns TokenMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): TokenMetadata; ++ ++ /** ++ * Decodes a TokenMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns TokenMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): TokenMetadata; ++ ++ /** ++ * Verifies a TokenMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a TokenMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns TokenMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): TokenMetadata; ++ ++ /** ++ * Creates a plain object from a TokenMetadata message. Also converts values to other types if specified. ++ * @param message TokenMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: TokenMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this TokenMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a Benefit. */ ++export interface IBenefit { ++ ++ /** Benefit title */ ++ title?: (string|null); ++ ++ /** Benefit description */ ++ description?: (string|null); ++ ++ /** Benefit emoji */ ++ emoji?: (string|null); ++ ++ /** Benefit displayOrder */ ++ displayOrder?: (number|null); ++} ++ ++/** Represents a Benefit. */ ++export class Benefit implements IBenefit { ++ ++ /** ++ * Constructs a new Benefit. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IBenefit); ++ ++ /** Benefit title. */ ++ public title: string; ++ ++ /** Benefit description. */ ++ public description: string; ++ ++ /** Benefit emoji. */ ++ public emoji: string; ++ ++ /** Benefit displayOrder. */ ++ public displayOrder: number; ++ ++ /** ++ * Creates a new Benefit instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns Benefit instance ++ */ ++ public static create(properties?: IBenefit): Benefit; ++ ++ /** ++ * Encodes the specified Benefit message. Does not implicitly {@link Benefit.verify|verify} messages. ++ * @param message Benefit message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IBenefit, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified Benefit message, length delimited. Does not implicitly {@link Benefit.verify|verify} messages. ++ * @param message Benefit message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IBenefit, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a Benefit message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns Benefit ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): Benefit; ++ ++ /** ++ * Decodes a Benefit message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns Benefit ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): Benefit; ++ ++ /** ++ * Verifies a Benefit message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a Benefit message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns Benefit ++ */ ++ public static fromObject(object: { [k: string]: any }): Benefit; ++ ++ /** ++ * Creates a plain object from a Benefit message. Also converts values to other types if specified. ++ * @param message Benefit ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: Benefit, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this Benefit to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a SaleMetadata. */ ++export interface ISaleMetadata { ++ ++ /** SaleMetadata termsAndConditions */ ++ termsAndConditions?: (string|null); ++} ++ ++/** Represents a SaleMetadata. */ ++export class SaleMetadata implements ISaleMetadata { ++ ++ /** ++ * Constructs a new SaleMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: ISaleMetadata); ++ ++ /** SaleMetadata termsAndConditions. */ ++ public termsAndConditions: string; ++ ++ /** ++ * Creates a new SaleMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns SaleMetadata instance ++ */ ++ public static create(properties?: ISaleMetadata): SaleMetadata; ++ ++ /** ++ * Encodes the specified SaleMetadata message. Does not implicitly {@link SaleMetadata.verify|verify} messages. ++ * @param message SaleMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: ISaleMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified SaleMetadata message, length delimited. Does not implicitly {@link SaleMetadata.verify|verify} messages. ++ * @param message SaleMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: ISaleMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a SaleMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns SaleMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): SaleMetadata; ++ ++ /** ++ * Decodes a SaleMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns SaleMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): SaleMetadata; ++ ++ /** ++ * Verifies a SaleMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a SaleMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns SaleMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): SaleMetadata; ++ ++ /** ++ * Creates a plain object from a SaleMetadata message. Also converts values to other types if specified. ++ * @param message SaleMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: SaleMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this SaleMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a PublishedBeforeJoystream. */ ++export interface IPublishedBeforeJoystream { ++ ++ /** PublishedBeforeJoystream isPublished */ ++ isPublished?: (boolean|null); ++ ++ /** PublishedBeforeJoystream date */ ++ date?: (string|null); ++} ++ ++/** Represents a PublishedBeforeJoystream. */ ++export class PublishedBeforeJoystream implements IPublishedBeforeJoystream { ++ ++ /** ++ * Constructs a new PublishedBeforeJoystream. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IPublishedBeforeJoystream); ++ ++ /** PublishedBeforeJoystream isPublished. */ ++ public isPublished: boolean; ++ ++ /** PublishedBeforeJoystream date. */ ++ public date: string; ++ ++ /** ++ * Creates a new PublishedBeforeJoystream instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns PublishedBeforeJoystream instance ++ */ ++ public static create(properties?: IPublishedBeforeJoystream): PublishedBeforeJoystream; ++ ++ /** ++ * Encodes the specified PublishedBeforeJoystream message. Does not implicitly {@link PublishedBeforeJoystream.verify|verify} messages. ++ * @param message PublishedBeforeJoystream message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IPublishedBeforeJoystream, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified PublishedBeforeJoystream message, length delimited. Does not implicitly {@link PublishedBeforeJoystream.verify|verify} messages. ++ * @param message PublishedBeforeJoystream message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IPublishedBeforeJoystream, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a PublishedBeforeJoystream message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns PublishedBeforeJoystream ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): PublishedBeforeJoystream; ++ ++ /** ++ * Decodes a PublishedBeforeJoystream message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns PublishedBeforeJoystream ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): PublishedBeforeJoystream; ++ ++ /** ++ * Verifies a PublishedBeforeJoystream message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a PublishedBeforeJoystream message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns PublishedBeforeJoystream ++ */ ++ public static fromObject(object: { [k: string]: any }): PublishedBeforeJoystream; ++ ++ /** ++ * Creates a plain object from a PublishedBeforeJoystream message. Also converts values to other types if specified. ++ * @param message PublishedBeforeJoystream ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: PublishedBeforeJoystream, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this PublishedBeforeJoystream to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a License. */ ++export interface ILicense { ++ ++ /** License code */ ++ code?: (number|null); ++ ++ /** License attribution */ ++ attribution?: (string|null); ++ ++ /** License customText */ ++ customText?: (string|null); ++} ++ ++/** Represents a License. */ ++export class License implements ILicense { ++ ++ /** ++ * Constructs a new License. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: ILicense); ++ ++ /** License code. */ ++ public code: number; ++ ++ /** License attribution. */ ++ public attribution: string; ++ ++ /** License customText. */ ++ public customText: string; ++ ++ /** ++ * Creates a new License instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns License instance ++ */ ++ public static create(properties?: ILicense): License; ++ ++ /** ++ * Encodes the specified License message. Does not implicitly {@link License.verify|verify} messages. ++ * @param message License message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: ILicense, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified License message, length delimited. Does not implicitly {@link License.verify|verify} messages. ++ * @param message License message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: ILicense, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a License message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns License ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): License; ++ ++ /** ++ * Decodes a License message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns License ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): License; ++ ++ /** ++ * Verifies a License message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a License message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns License ++ */ ++ public static fromObject(object: { [k: string]: any }): License; ++ ++ /** ++ * Creates a plain object from a License message. Also converts values to other types if specified. ++ * @param message License ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: License, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this License to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a MediaType. */ ++export interface IMediaType { ++ ++ /** MediaType codecName */ ++ codecName?: (string|null); ++ ++ /** MediaType container */ ++ container?: (string|null); ++ ++ /** MediaType mimeMediaType */ ++ mimeMediaType?: (string|null); ++} ++ ++/** Represents a MediaType. */ ++export class MediaType implements IMediaType { ++ ++ /** ++ * Constructs a new MediaType. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IMediaType); ++ ++ /** MediaType codecName. */ ++ public codecName: string; ++ ++ /** MediaType container. */ ++ public container: string; ++ ++ /** MediaType mimeMediaType. */ ++ public mimeMediaType: string; ++ ++ /** ++ * Creates a new MediaType instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns MediaType instance ++ */ ++ public static create(properties?: IMediaType): MediaType; ++ ++ /** ++ * Encodes the specified MediaType message. Does not implicitly {@link MediaType.verify|verify} messages. ++ * @param message MediaType message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IMediaType, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified MediaType message, length delimited. Does not implicitly {@link MediaType.verify|verify} messages. ++ * @param message MediaType message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IMediaType, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a MediaType message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns MediaType ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): MediaType; ++ ++ /** ++ * Decodes a MediaType message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns MediaType ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): MediaType; ++ ++ /** ++ * Verifies a MediaType message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a MediaType message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns MediaType ++ */ ++ public static fromObject(object: { [k: string]: any }): MediaType; ++ ++ /** ++ * Creates a plain object from a MediaType message. Also converts values to other types if specified. ++ * @param message MediaType ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: MediaType, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this MediaType to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a SubtitleMetadata. */ ++export interface ISubtitleMetadata { ++ ++ /** SubtitleMetadata type */ ++ type: string; ++ ++ /** SubtitleMetadata newAsset */ ++ newAsset?: (number|null); ++ ++ /** SubtitleMetadata language */ ++ language: string; ++ ++ /** SubtitleMetadata mimeType */ ++ mimeType: string; ++} ++ ++/** Represents a SubtitleMetadata. */ ++export class SubtitleMetadata implements ISubtitleMetadata { ++ ++ /** ++ * Constructs a new SubtitleMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: ISubtitleMetadata); ++ ++ /** SubtitleMetadata type. */ ++ public type: string; ++ ++ /** SubtitleMetadata newAsset. */ ++ public newAsset: number; ++ ++ /** SubtitleMetadata language. */ ++ public language: string; ++ ++ /** SubtitleMetadata mimeType. */ ++ public mimeType: string; ++ ++ /** ++ * Creates a new SubtitleMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns SubtitleMetadata instance ++ */ ++ public static create(properties?: ISubtitleMetadata): SubtitleMetadata; ++ ++ /** ++ * Encodes the specified SubtitleMetadata message. Does not implicitly {@link SubtitleMetadata.verify|verify} messages. ++ * @param message SubtitleMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: ISubtitleMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified SubtitleMetadata message, length delimited. Does not implicitly {@link SubtitleMetadata.verify|verify} messages. ++ * @param message SubtitleMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: ISubtitleMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a SubtitleMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns SubtitleMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): SubtitleMetadata; ++ ++ /** ++ * Decodes a SubtitleMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns SubtitleMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): SubtitleMetadata; ++ ++ /** ++ * Verifies a SubtitleMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a SubtitleMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns SubtitleMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): SubtitleMetadata; ++ ++ /** ++ * Creates a plain object from a SubtitleMetadata message. Also converts values to other types if specified. ++ * @param message SubtitleMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: SubtitleMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this SubtitleMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a VideoMetadata. */ ++export interface IVideoMetadata { ++ ++ /** VideoMetadata title */ ++ title?: (string|null); ++ ++ /** VideoMetadata description */ ++ description?: (string|null); ++ ++ /** VideoMetadata video */ ++ video?: (number|null); ++ ++ /** VideoMetadata thumbnailPhoto */ ++ thumbnailPhoto?: (number|null); ++ ++ /** VideoMetadata duration */ ++ duration?: (number|null); ++ ++ /** VideoMetadata mediaPixelHeight */ ++ mediaPixelHeight?: (number|null); ++ ++ /** VideoMetadata mediaPixelWidth */ ++ mediaPixelWidth?: (number|null); ++ ++ /** VideoMetadata mediaType */ ++ mediaType?: (IMediaType|null); ++ ++ /** VideoMetadata language */ ++ language?: (string|null); ++ ++ /** VideoMetadata license */ ++ license?: (ILicense|null); ++ ++ /** VideoMetadata publishedBeforeJoystream */ ++ publishedBeforeJoystream?: (IPublishedBeforeJoystream|null); ++ ++ /** VideoMetadata hasMarketing */ ++ hasMarketing?: (boolean|null); ++ ++ /** VideoMetadata isPublic */ ++ isPublic?: (boolean|null); ++ ++ /** VideoMetadata isExplicit */ ++ isExplicit?: (boolean|null); ++ ++ /** VideoMetadata persons */ ++ persons?: (Long[]|null); ++ ++ /** VideoMetadata category */ ++ category?: (string|null); ++ ++ /** VideoMetadata subtitles */ ++ subtitles?: (ISubtitleMetadata[]|null); ++ ++ /** VideoMetadata enableComments */ ++ enableComments?: (boolean|null); ++ ++ /** VideoMetadata clearSubtitles */ ++ clearSubtitles?: (boolean|null); ++} ++ ++/** Represents a VideoMetadata. */ ++export class VideoMetadata implements IVideoMetadata { ++ ++ /** ++ * Constructs a new VideoMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IVideoMetadata); ++ ++ /** VideoMetadata title. */ ++ public title: string; ++ ++ /** VideoMetadata description. */ ++ public description: string; ++ ++ /** VideoMetadata video. */ ++ public video: number; ++ ++ /** VideoMetadata thumbnailPhoto. */ ++ public thumbnailPhoto: number; ++ ++ /** VideoMetadata duration. */ ++ public duration: number; ++ ++ /** VideoMetadata mediaPixelHeight. */ ++ public mediaPixelHeight: number; ++ ++ /** VideoMetadata mediaPixelWidth. */ ++ public mediaPixelWidth: number; ++ ++ /** VideoMetadata mediaType. */ ++ public mediaType?: (IMediaType|null); ++ ++ /** VideoMetadata language. */ ++ public language: string; ++ ++ /** VideoMetadata license. */ ++ public license?: (ILicense|null); ++ ++ /** VideoMetadata publishedBeforeJoystream. */ ++ public publishedBeforeJoystream?: (IPublishedBeforeJoystream|null); ++ ++ /** VideoMetadata hasMarketing. */ ++ public hasMarketing: boolean; ++ ++ /** VideoMetadata isPublic. */ ++ public isPublic: boolean; ++ ++ /** VideoMetadata isExplicit. */ ++ public isExplicit: boolean; ++ ++ /** VideoMetadata persons. */ ++ public persons: Long[]; ++ ++ /** VideoMetadata category. */ ++ public category: string; ++ ++ /** VideoMetadata subtitles. */ ++ public subtitles: ISubtitleMetadata[]; ++ ++ /** VideoMetadata enableComments. */ ++ public enableComments: boolean; ++ ++ /** VideoMetadata clearSubtitles. */ ++ public clearSubtitles: boolean; ++ ++ /** ++ * Creates a new VideoMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns VideoMetadata instance ++ */ ++ public static create(properties?: IVideoMetadata): VideoMetadata; ++ ++ /** ++ * Encodes the specified VideoMetadata message. Does not implicitly {@link VideoMetadata.verify|verify} messages. ++ * @param message VideoMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IVideoMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified VideoMetadata message, length delimited. Does not implicitly {@link VideoMetadata.verify|verify} messages. ++ * @param message VideoMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IVideoMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a VideoMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns VideoMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): VideoMetadata; ++ ++ /** ++ * Decodes a VideoMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns VideoMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): VideoMetadata; ++ ++ /** ++ * Verifies a VideoMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a VideoMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns VideoMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): VideoMetadata; ++ ++ /** ++ * Creates a plain object from a VideoMetadata message. Also converts values to other types if specified. ++ * @param message VideoMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: VideoMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this VideoMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a ContentMetadata. */ ++export interface IContentMetadata { ++ ++ /** ContentMetadata videoMetadata */ ++ videoMetadata?: (IVideoMetadata|null); ++} ++ ++/** Represents a ContentMetadata. */ ++export class ContentMetadata implements IContentMetadata { ++ ++ /** ++ * Constructs a new ContentMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IContentMetadata); ++ ++ /** ContentMetadata videoMetadata. */ ++ public videoMetadata?: (IVideoMetadata|null); ++ ++ /** ContentMetadata contentMetadata. */ ++ public contentMetadata?: "videoMetadata"; ++ ++ /** ++ * Creates a new ContentMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns ContentMetadata instance ++ */ ++ public static create(properties?: IContentMetadata): ContentMetadata; ++ ++ /** ++ * Encodes the specified ContentMetadata message. Does not implicitly {@link ContentMetadata.verify|verify} messages. ++ * @param message ContentMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IContentMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified ContentMetadata message, length delimited. Does not implicitly {@link ContentMetadata.verify|verify} messages. ++ * @param message ContentMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IContentMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a ContentMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns ContentMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): ContentMetadata; ++ ++ /** ++ * Decodes a ContentMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns ContentMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): ContentMetadata; ++ ++ /** ++ * Verifies a ContentMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a ContentMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns ContentMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): ContentMetadata; ++ ++ /** ++ * Creates a plain object from a ContentMetadata message. Also converts values to other types if specified. ++ * @param message ContentMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: ContentMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this ContentMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of an OpeningMetadata. */ ++export interface IOpeningMetadata { ++ ++ /** OpeningMetadata shortDescription */ ++ shortDescription?: (string|null); ++ ++ /** OpeningMetadata description */ ++ description?: (string|null); ++ ++ /** OpeningMetadata hiringLimit */ ++ hiringLimit?: (number|null); ++ ++ /** OpeningMetadata expectedEndingTimestamp */ ++ expectedEndingTimestamp?: (number|null); ++ ++ /** OpeningMetadata applicationDetails */ ++ applicationDetails?: (string|null); ++ ++ /** OpeningMetadata applicationFormQuestions */ ++ applicationFormQuestions?: (OpeningMetadata.IApplicationFormQuestion[]|null); ++ ++ /** OpeningMetadata title */ ++ title?: (string|null); ++} ++ ++/** Represents an OpeningMetadata. */ ++export class OpeningMetadata implements IOpeningMetadata { ++ ++ /** ++ * Constructs a new OpeningMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IOpeningMetadata); ++ ++ /** OpeningMetadata shortDescription. */ ++ public shortDescription: string; ++ ++ /** OpeningMetadata description. */ ++ public description: string; ++ ++ /** OpeningMetadata hiringLimit. */ ++ public hiringLimit: number; ++ ++ /** OpeningMetadata expectedEndingTimestamp. */ ++ public expectedEndingTimestamp: number; ++ ++ /** OpeningMetadata applicationDetails. */ ++ public applicationDetails: string; ++ ++ /** OpeningMetadata applicationFormQuestions. */ ++ public applicationFormQuestions: OpeningMetadata.IApplicationFormQuestion[]; ++ ++ /** OpeningMetadata title. */ ++ public title: string; ++ ++ /** ++ * Creates a new OpeningMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns OpeningMetadata instance ++ */ ++ public static create(properties?: IOpeningMetadata): OpeningMetadata; ++ ++ /** ++ * Encodes the specified OpeningMetadata message. Does not implicitly {@link OpeningMetadata.verify|verify} messages. ++ * @param message OpeningMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IOpeningMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified OpeningMetadata message, length delimited. Does not implicitly {@link OpeningMetadata.verify|verify} messages. ++ * @param message OpeningMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IOpeningMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes an OpeningMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns OpeningMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): OpeningMetadata; ++ ++ /** ++ * Decodes an OpeningMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns OpeningMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): OpeningMetadata; ++ ++ /** ++ * Verifies an OpeningMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates an OpeningMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns OpeningMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): OpeningMetadata; ++ ++ /** ++ * Creates a plain object from an OpeningMetadata message. Also converts values to other types if specified. ++ * @param message OpeningMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: OpeningMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this OpeningMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++export namespace OpeningMetadata { ++ ++ /** Properties of an ApplicationFormQuestion. */ ++ interface IApplicationFormQuestion { ++ ++ /** ApplicationFormQuestion question */ ++ question?: (string|null); ++ ++ /** ApplicationFormQuestion type */ ++ type?: (OpeningMetadata.ApplicationFormQuestion.InputType|null); ++ } ++ ++ /** Represents an ApplicationFormQuestion. */ ++ class ApplicationFormQuestion implements IApplicationFormQuestion { ++ ++ /** ++ * Constructs a new ApplicationFormQuestion. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: OpeningMetadata.IApplicationFormQuestion); ++ ++ /** ApplicationFormQuestion question. */ ++ public question: string; ++ ++ /** ApplicationFormQuestion type. */ ++ public type: OpeningMetadata.ApplicationFormQuestion.InputType; ++ ++ /** ++ * Creates a new ApplicationFormQuestion instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns ApplicationFormQuestion instance ++ */ ++ public static create(properties?: OpeningMetadata.IApplicationFormQuestion): OpeningMetadata.ApplicationFormQuestion; ++ ++ /** ++ * Encodes the specified ApplicationFormQuestion message. Does not implicitly {@link OpeningMetadata.ApplicationFormQuestion.verify|verify} messages. ++ * @param message ApplicationFormQuestion message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: OpeningMetadata.IApplicationFormQuestion, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified ApplicationFormQuestion message, length delimited. Does not implicitly {@link OpeningMetadata.ApplicationFormQuestion.verify|verify} messages. ++ * @param message ApplicationFormQuestion message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: OpeningMetadata.IApplicationFormQuestion, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes an ApplicationFormQuestion message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns ApplicationFormQuestion ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): OpeningMetadata.ApplicationFormQuestion; ++ ++ /** ++ * Decodes an ApplicationFormQuestion message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns ApplicationFormQuestion ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): OpeningMetadata.ApplicationFormQuestion; ++ ++ /** ++ * Verifies an ApplicationFormQuestion message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates an ApplicationFormQuestion message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns ApplicationFormQuestion ++ */ ++ public static fromObject(object: { [k: string]: any }): OpeningMetadata.ApplicationFormQuestion; ++ ++ /** ++ * Creates a plain object from an ApplicationFormQuestion message. Also converts values to other types if specified. ++ * @param message ApplicationFormQuestion ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: OpeningMetadata.ApplicationFormQuestion, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this ApplicationFormQuestion to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++ } ++ ++ namespace ApplicationFormQuestion { ++ ++ /** InputType enum. */ ++ enum InputType { ++ TEXTAREA = 0, ++ TEXT = 1 ++ } ++ } ++} ++ ++/** Properties of an UpcomingOpeningMetadata. */ ++export interface IUpcomingOpeningMetadata { ++ ++ /** UpcomingOpeningMetadata expectedStart */ ++ expectedStart?: (number|null); ++ ++ /** UpcomingOpeningMetadata rewardPerBlock */ ++ rewardPerBlock?: (Long|null); ++ ++ /** UpcomingOpeningMetadata minApplicationStake */ ++ minApplicationStake?: (Long|null); ++ ++ /** UpcomingOpeningMetadata metadata */ ++ metadata?: (IOpeningMetadata|null); ++} ++ ++/** Represents an UpcomingOpeningMetadata. */ ++export class UpcomingOpeningMetadata implements IUpcomingOpeningMetadata { ++ ++ /** ++ * Constructs a new UpcomingOpeningMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IUpcomingOpeningMetadata); ++ ++ /** UpcomingOpeningMetadata expectedStart. */ ++ public expectedStart: number; ++ ++ /** UpcomingOpeningMetadata rewardPerBlock. */ ++ public rewardPerBlock: Long; ++ ++ /** UpcomingOpeningMetadata minApplicationStake. */ ++ public minApplicationStake: Long; ++ ++ /** UpcomingOpeningMetadata metadata. */ ++ public metadata?: (IOpeningMetadata|null); ++ ++ /** ++ * Creates a new UpcomingOpeningMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns UpcomingOpeningMetadata instance ++ */ ++ public static create(properties?: IUpcomingOpeningMetadata): UpcomingOpeningMetadata; ++ ++ /** ++ * Encodes the specified UpcomingOpeningMetadata message. Does not implicitly {@link UpcomingOpeningMetadata.verify|verify} messages. ++ * @param message UpcomingOpeningMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IUpcomingOpeningMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified UpcomingOpeningMetadata message, length delimited. Does not implicitly {@link UpcomingOpeningMetadata.verify|verify} messages. ++ * @param message UpcomingOpeningMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IUpcomingOpeningMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes an UpcomingOpeningMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns UpcomingOpeningMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): UpcomingOpeningMetadata; ++ ++ /** ++ * Decodes an UpcomingOpeningMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns UpcomingOpeningMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): UpcomingOpeningMetadata; ++ ++ /** ++ * Verifies an UpcomingOpeningMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates an UpcomingOpeningMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns UpcomingOpeningMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): UpcomingOpeningMetadata; ++ ++ /** ++ * Creates a plain object from an UpcomingOpeningMetadata message. Also converts values to other types if specified. ++ * @param message UpcomingOpeningMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: UpcomingOpeningMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this UpcomingOpeningMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of an ApplicationMetadata. */ ++export interface IApplicationMetadata { ++ ++ /** ApplicationMetadata answers */ ++ answers?: (string[]|null); ++} ++ ++/** Represents an ApplicationMetadata. */ ++export class ApplicationMetadata implements IApplicationMetadata { ++ ++ /** ++ * Constructs a new ApplicationMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IApplicationMetadata); ++ ++ /** ApplicationMetadata answers. */ ++ public answers: string[]; ++ ++ /** ++ * Creates a new ApplicationMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns ApplicationMetadata instance ++ */ ++ public static create(properties?: IApplicationMetadata): ApplicationMetadata; ++ ++ /** ++ * Encodes the specified ApplicationMetadata message. Does not implicitly {@link ApplicationMetadata.verify|verify} messages. ++ * @param message ApplicationMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IApplicationMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified ApplicationMetadata message, length delimited. Does not implicitly {@link ApplicationMetadata.verify|verify} messages. ++ * @param message ApplicationMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IApplicationMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes an ApplicationMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns ApplicationMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): ApplicationMetadata; ++ ++ /** ++ * Decodes an ApplicationMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns ApplicationMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): ApplicationMetadata; ++ ++ /** ++ * Verifies an ApplicationMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates an ApplicationMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns ApplicationMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): ApplicationMetadata; ++ ++ /** ++ * Creates a plain object from an ApplicationMetadata message. Also converts values to other types if specified. ++ * @param message ApplicationMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: ApplicationMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this ApplicationMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a WorkingGroupMetadata. */ ++export interface IWorkingGroupMetadata { ++ ++ /** WorkingGroupMetadata description */ ++ description?: (string|null); ++ ++ /** WorkingGroupMetadata about */ ++ about?: (string|null); ++ ++ /** WorkingGroupMetadata status */ ++ status?: (string|null); ++ ++ /** WorkingGroupMetadata statusMessage */ ++ statusMessage?: (string|null); ++} ++ ++/** Represents a WorkingGroupMetadata. */ ++export class WorkingGroupMetadata implements IWorkingGroupMetadata { ++ ++ /** ++ * Constructs a new WorkingGroupMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IWorkingGroupMetadata); ++ ++ /** WorkingGroupMetadata description. */ ++ public description: string; ++ ++ /** WorkingGroupMetadata about. */ ++ public about: string; ++ ++ /** WorkingGroupMetadata status. */ ++ public status: string; ++ ++ /** WorkingGroupMetadata statusMessage. */ ++ public statusMessage: string; ++ ++ /** ++ * Creates a new WorkingGroupMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns WorkingGroupMetadata instance ++ */ ++ public static create(properties?: IWorkingGroupMetadata): WorkingGroupMetadata; ++ ++ /** ++ * Encodes the specified WorkingGroupMetadata message. Does not implicitly {@link WorkingGroupMetadata.verify|verify} messages. ++ * @param message WorkingGroupMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IWorkingGroupMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified WorkingGroupMetadata message, length delimited. Does not implicitly {@link WorkingGroupMetadata.verify|verify} messages. ++ * @param message WorkingGroupMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IWorkingGroupMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a WorkingGroupMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns WorkingGroupMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): WorkingGroupMetadata; ++ ++ /** ++ * Decodes a WorkingGroupMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns WorkingGroupMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): WorkingGroupMetadata; ++ ++ /** ++ * Verifies a WorkingGroupMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a WorkingGroupMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns WorkingGroupMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): WorkingGroupMetadata; ++ ++ /** ++ * Creates a plain object from a WorkingGroupMetadata message. Also converts values to other types if specified. ++ * @param message WorkingGroupMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: WorkingGroupMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this WorkingGroupMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a SetGroupMetadata. */ ++export interface ISetGroupMetadata { ++ ++ /** SetGroupMetadata newMetadata */ ++ newMetadata?: (IWorkingGroupMetadata|null); ++} ++ ++/** Represents a SetGroupMetadata. */ ++export class SetGroupMetadata implements ISetGroupMetadata { ++ ++ /** ++ * Constructs a new SetGroupMetadata. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: ISetGroupMetadata); ++ ++ /** SetGroupMetadata newMetadata. */ ++ public newMetadata?: (IWorkingGroupMetadata|null); ++ ++ /** ++ * Creates a new SetGroupMetadata instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns SetGroupMetadata instance ++ */ ++ public static create(properties?: ISetGroupMetadata): SetGroupMetadata; ++ ++ /** ++ * Encodes the specified SetGroupMetadata message. Does not implicitly {@link SetGroupMetadata.verify|verify} messages. ++ * @param message SetGroupMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: ISetGroupMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified SetGroupMetadata message, length delimited. Does not implicitly {@link SetGroupMetadata.verify|verify} messages. ++ * @param message SetGroupMetadata message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: ISetGroupMetadata, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a SetGroupMetadata message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns SetGroupMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): SetGroupMetadata; ++ ++ /** ++ * Decodes a SetGroupMetadata message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns SetGroupMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): SetGroupMetadata; ++ ++ /** ++ * Verifies a SetGroupMetadata message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a SetGroupMetadata message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns SetGroupMetadata ++ */ ++ public static fromObject(object: { [k: string]: any }): SetGroupMetadata; ++ ++ /** ++ * Creates a plain object from a SetGroupMetadata message. Also converts values to other types if specified. ++ * @param message SetGroupMetadata ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: SetGroupMetadata, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this SetGroupMetadata to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of an AddUpcomingOpening. */ ++export interface IAddUpcomingOpening { ++ ++ /** AddUpcomingOpening metadata */ ++ metadata?: (IUpcomingOpeningMetadata|null); ++} ++ ++/** Represents an AddUpcomingOpening. */ ++export class AddUpcomingOpening implements IAddUpcomingOpening { ++ ++ /** ++ * Constructs a new AddUpcomingOpening. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IAddUpcomingOpening); ++ ++ /** AddUpcomingOpening metadata. */ ++ public metadata?: (IUpcomingOpeningMetadata|null); ++ ++ /** ++ * Creates a new AddUpcomingOpening instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns AddUpcomingOpening instance ++ */ ++ public static create(properties?: IAddUpcomingOpening): AddUpcomingOpening; ++ ++ /** ++ * Encodes the specified AddUpcomingOpening message. Does not implicitly {@link AddUpcomingOpening.verify|verify} messages. ++ * @param message AddUpcomingOpening message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IAddUpcomingOpening, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified AddUpcomingOpening message, length delimited. Does not implicitly {@link AddUpcomingOpening.verify|verify} messages. ++ * @param message AddUpcomingOpening message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IAddUpcomingOpening, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes an AddUpcomingOpening message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns AddUpcomingOpening ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): AddUpcomingOpening; ++ ++ /** ++ * Decodes an AddUpcomingOpening message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns AddUpcomingOpening ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): AddUpcomingOpening; ++ ++ /** ++ * Verifies an AddUpcomingOpening message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates an AddUpcomingOpening message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns AddUpcomingOpening ++ */ ++ public static fromObject(object: { [k: string]: any }): AddUpcomingOpening; ++ ++ /** ++ * Creates a plain object from an AddUpcomingOpening message. Also converts values to other types if specified. ++ * @param message AddUpcomingOpening ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: AddUpcomingOpening, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this AddUpcomingOpening to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a RemoveUpcomingOpening. */ ++export interface IRemoveUpcomingOpening { ++ ++ /** RemoveUpcomingOpening id */ ++ id?: (string|null); ++} ++ ++/** Represents a RemoveUpcomingOpening. */ ++export class RemoveUpcomingOpening implements IRemoveUpcomingOpening { ++ ++ /** ++ * Constructs a new RemoveUpcomingOpening. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IRemoveUpcomingOpening); ++ ++ /** RemoveUpcomingOpening id. */ ++ public id: string; ++ ++ /** ++ * Creates a new RemoveUpcomingOpening instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns RemoveUpcomingOpening instance ++ */ ++ public static create(properties?: IRemoveUpcomingOpening): RemoveUpcomingOpening; ++ ++ /** ++ * Encodes the specified RemoveUpcomingOpening message. Does not implicitly {@link RemoveUpcomingOpening.verify|verify} messages. ++ * @param message RemoveUpcomingOpening message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IRemoveUpcomingOpening, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified RemoveUpcomingOpening message, length delimited. Does not implicitly {@link RemoveUpcomingOpening.verify|verify} messages. ++ * @param message RemoveUpcomingOpening message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IRemoveUpcomingOpening, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a RemoveUpcomingOpening message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns RemoveUpcomingOpening ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): RemoveUpcomingOpening; ++ ++ /** ++ * Decodes a RemoveUpcomingOpening message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns RemoveUpcomingOpening ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): RemoveUpcomingOpening; ++ ++ /** ++ * Verifies a RemoveUpcomingOpening message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a RemoveUpcomingOpening message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns RemoveUpcomingOpening ++ */ ++ public static fromObject(object: { [k: string]: any }): RemoveUpcomingOpening; ++ ++ /** ++ * Creates a plain object from a RemoveUpcomingOpening message. Also converts values to other types if specified. ++ * @param message RemoveUpcomingOpening ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: RemoveUpcomingOpening, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this RemoveUpcomingOpening to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a WorkingGroupMetadataAction. */ ++export interface IWorkingGroupMetadataAction { ++ ++ /** WorkingGroupMetadataAction setGroupMetadata */ ++ setGroupMetadata?: (ISetGroupMetadata|null); ++ ++ /** WorkingGroupMetadataAction addUpcomingOpening */ ++ addUpcomingOpening?: (IAddUpcomingOpening|null); ++ ++ /** WorkingGroupMetadataAction removeUpcomingOpening */ ++ removeUpcomingOpening?: (IRemoveUpcomingOpening|null); ++} ++ ++/** Represents a WorkingGroupMetadataAction. */ ++export class WorkingGroupMetadataAction implements IWorkingGroupMetadataAction { ++ ++ /** ++ * Constructs a new WorkingGroupMetadataAction. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IWorkingGroupMetadataAction); ++ ++ /** WorkingGroupMetadataAction setGroupMetadata. */ ++ public setGroupMetadata?: (ISetGroupMetadata|null); ++ ++ /** WorkingGroupMetadataAction addUpcomingOpening. */ ++ public addUpcomingOpening?: (IAddUpcomingOpening|null); ++ ++ /** WorkingGroupMetadataAction removeUpcomingOpening. */ ++ public removeUpcomingOpening?: (IRemoveUpcomingOpening|null); ++ ++ /** WorkingGroupMetadataAction action. */ ++ public action?: ("setGroupMetadata"|"addUpcomingOpening"|"removeUpcomingOpening"); ++ ++ /** ++ * Creates a new WorkingGroupMetadataAction instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns WorkingGroupMetadataAction instance ++ */ ++ public static create(properties?: IWorkingGroupMetadataAction): WorkingGroupMetadataAction; ++ ++ /** ++ * Encodes the specified WorkingGroupMetadataAction message. Does not implicitly {@link WorkingGroupMetadataAction.verify|verify} messages. ++ * @param message WorkingGroupMetadataAction message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IWorkingGroupMetadataAction, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified WorkingGroupMetadataAction message, length delimited. Does not implicitly {@link WorkingGroupMetadataAction.verify|verify} messages. ++ * @param message WorkingGroupMetadataAction message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IWorkingGroupMetadataAction, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a WorkingGroupMetadataAction message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns WorkingGroupMetadataAction ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): WorkingGroupMetadataAction; ++ ++ /** ++ * Decodes a WorkingGroupMetadataAction message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns WorkingGroupMetadataAction ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): WorkingGroupMetadataAction; ++ ++ /** ++ * Verifies a WorkingGroupMetadataAction message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a WorkingGroupMetadataAction message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns WorkingGroupMetadataAction ++ */ ++ public static fromObject(object: { [k: string]: any }): WorkingGroupMetadataAction; ++ ++ /** ++ * Creates a plain object from a WorkingGroupMetadataAction message. Also converts values to other types if specified. ++ * @param message WorkingGroupMetadataAction ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: WorkingGroupMetadataAction, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this WorkingGroupMetadataAction to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a ModeratePost. */ ++export interface IModeratePost { ++ ++ /** ModeratePost postId */ ++ postId: Long; ++ ++ /** ModeratePost rationale */ ++ rationale: string; ++} ++ ++/** Represents a ModeratePost. */ ++export class ModeratePost implements IModeratePost { ++ ++ /** ++ * Constructs a new ModeratePost. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IModeratePost); ++ ++ /** ModeratePost postId. */ ++ public postId: Long; ++ ++ /** ModeratePost rationale. */ ++ public rationale: string; ++ ++ /** ++ * Creates a new ModeratePost instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns ModeratePost instance ++ */ ++ public static create(properties?: IModeratePost): ModeratePost; ++ ++ /** ++ * Encodes the specified ModeratePost message. Does not implicitly {@link ModeratePost.verify|verify} messages. ++ * @param message ModeratePost message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IModeratePost, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified ModeratePost message, length delimited. Does not implicitly {@link ModeratePost.verify|verify} messages. ++ * @param message ModeratePost message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IModeratePost, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a ModeratePost message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns ModeratePost ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): ModeratePost; ++ ++ /** ++ * Decodes a ModeratePost message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns ModeratePost ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): ModeratePost; ++ ++ /** ++ * Verifies a ModeratePost message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a ModeratePost message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns ModeratePost ++ */ ++ public static fromObject(object: { [k: string]: any }): ModeratePost; ++ ++ /** ++ * Creates a plain object from a ModeratePost message. Also converts values to other types if specified. ++ * @param message ModeratePost ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: ModeratePost, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this ModeratePost to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} ++ ++/** Properties of a RemarkMetadataAction. */ ++export interface IRemarkMetadataAction { ++ ++ /** RemarkMetadataAction moderatePost */ ++ moderatePost?: (IModeratePost|null); ++} ++ ++/** Represents a RemarkMetadataAction. */ ++export class RemarkMetadataAction implements IRemarkMetadataAction { ++ ++ /** ++ * Constructs a new RemarkMetadataAction. ++ * @param [properties] Properties to set ++ */ ++ constructor(properties?: IRemarkMetadataAction); ++ ++ /** RemarkMetadataAction moderatePost. */ ++ public moderatePost?: (IModeratePost|null); ++ ++ /** RemarkMetadataAction action. */ ++ public action?: "moderatePost"; ++ ++ /** ++ * Creates a new RemarkMetadataAction instance using the specified properties. ++ * @param [properties] Properties to set ++ * @returns RemarkMetadataAction instance ++ */ ++ public static create(properties?: IRemarkMetadataAction): RemarkMetadataAction; ++ ++ /** ++ * Encodes the specified RemarkMetadataAction message. Does not implicitly {@link RemarkMetadataAction.verify|verify} messages. ++ * @param message RemarkMetadataAction message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encode(message: IRemarkMetadataAction, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Encodes the specified RemarkMetadataAction message, length delimited. Does not implicitly {@link RemarkMetadataAction.verify|verify} messages. ++ * @param message RemarkMetadataAction message or plain object to encode ++ * @param [writer] Writer to encode to ++ * @returns Writer ++ */ ++ public static encodeDelimited(message: IRemarkMetadataAction, writer?: $protobuf.Writer): $protobuf.Writer; ++ ++ /** ++ * Decodes a RemarkMetadataAction message from the specified reader or buffer. ++ * @param reader Reader or buffer to decode from ++ * @param [length] Message length if known beforehand ++ * @returns RemarkMetadataAction ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): RemarkMetadataAction; ++ ++ /** ++ * Decodes a RemarkMetadataAction message from the specified reader or buffer, length delimited. ++ * @param reader Reader or buffer to decode from ++ * @returns RemarkMetadataAction ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): RemarkMetadataAction; ++ ++ /** ++ * Verifies a RemarkMetadataAction message. ++ * @param message Plain object to verify ++ * @returns `null` if valid, otherwise the reason why it is not ++ */ ++ public static verify(message: { [k: string]: any }): (string|null); ++ ++ /** ++ * Creates a RemarkMetadataAction message from a plain object. Also converts values to their respective internal types. ++ * @param object Plain object ++ * @returns RemarkMetadataAction ++ */ ++ public static fromObject(object: { [k: string]: any }): RemarkMetadataAction; ++ ++ /** ++ * Creates a plain object from a RemarkMetadataAction message. Also converts values to other types if specified. ++ * @param message RemarkMetadataAction ++ * @param [options] Conversion options ++ * @returns Plain object ++ */ ++ public static toObject(message: RemarkMetadataAction, options?: $protobuf.IConversionOptions): { [k: string]: any }; ++ ++ /** ++ * Converts this RemarkMetadataAction to JSON. ++ * @returns JSON object ++ */ ++ public toJSON(): { [k: string]: any }; ++} +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/compiled/index.js b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/compiled/index.js +new file mode 100644 +index 0000000..b1d022b +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/compiled/index.js +@@ -0,0 +1,16807 @@ ++/*eslint-disable block-scoped-var, id-length, no-control-regex, no-magic-numbers, no-prototype-builtins, no-redeclare, no-shadow, no-var, sort-vars*/ ++"use strict"; ++ ++var $protobuf = require("protobufjs/minimal"); ++ ++// Common aliases ++var $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util; ++ ++// Exported root namespace ++var $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {}); ++ ++$root.AppActionMetadata = (function() { ++ ++ /** ++ * Properties of an AppActionMetadata. ++ * @exports IAppActionMetadata ++ * @interface IAppActionMetadata ++ * @property {string|null} [videoId] AppActionMetadata videoId ++ */ ++ ++ /** ++ * Constructs a new AppActionMetadata. ++ * @exports AppActionMetadata ++ * @classdesc Represents an AppActionMetadata. ++ * @implements IAppActionMetadata ++ * @constructor ++ * @param {IAppActionMetadata=} [properties] Properties to set ++ */ ++ function AppActionMetadata(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * AppActionMetadata videoId. ++ * @member {string} videoId ++ * @memberof AppActionMetadata ++ * @instance ++ */ ++ AppActionMetadata.prototype.videoId = ""; ++ ++ /** ++ * Creates a new AppActionMetadata instance using the specified properties. ++ * @function create ++ * @memberof AppActionMetadata ++ * @static ++ * @param {IAppActionMetadata=} [properties] Properties to set ++ * @returns {AppActionMetadata} AppActionMetadata instance ++ */ ++ AppActionMetadata.create = function create(properties) { ++ return new AppActionMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified AppActionMetadata message. Does not implicitly {@link AppActionMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof AppActionMetadata ++ * @static ++ * @param {IAppActionMetadata} message AppActionMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ AppActionMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.videoId != null && Object.hasOwnProperty.call(message, "videoId")) ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.videoId); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified AppActionMetadata message, length delimited. Does not implicitly {@link AppActionMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof AppActionMetadata ++ * @static ++ * @param {IAppActionMetadata} message AppActionMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ AppActionMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes an AppActionMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof AppActionMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {AppActionMetadata} AppActionMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ AppActionMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.AppActionMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 2: ++ message.videoId = reader.string(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes an AppActionMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof AppActionMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {AppActionMetadata} AppActionMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ AppActionMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies an AppActionMetadata message. ++ * @function verify ++ * @memberof AppActionMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ AppActionMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.videoId != null && message.hasOwnProperty("videoId")) ++ if (!$util.isString(message.videoId)) ++ return "videoId: string expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates an AppActionMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof AppActionMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {AppActionMetadata} AppActionMetadata ++ */ ++ AppActionMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.AppActionMetadata) ++ return object; ++ var message = new $root.AppActionMetadata(); ++ if (object.videoId != null) ++ message.videoId = String(object.videoId); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from an AppActionMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof AppActionMetadata ++ * @static ++ * @param {AppActionMetadata} message AppActionMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ AppActionMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) ++ object.videoId = ""; ++ if (message.videoId != null && message.hasOwnProperty("videoId")) ++ object.videoId = message.videoId; ++ return object; ++ }; ++ ++ /** ++ * Converts this AppActionMetadata to JSON. ++ * @function toJSON ++ * @memberof AppActionMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ AppActionMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return AppActionMetadata; ++})(); ++ ++$root.AppAction = (function() { ++ ++ /** ++ * Properties of an AppAction. ++ * @exports IAppAction ++ * @interface IAppAction ++ * @property {string} appId AppAction appId ++ * @property {Uint8Array|null} [metadata] AppAction metadata ++ * @property {Uint8Array|null} [rawAction] AppAction rawAction ++ * @property {Uint8Array|null} [signature] AppAction signature ++ */ ++ ++ /** ++ * Constructs a new AppAction. ++ * @exports AppAction ++ * @classdesc Represents an AppAction. ++ * @implements IAppAction ++ * @constructor ++ * @param {IAppAction=} [properties] Properties to set ++ */ ++ function AppAction(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * AppAction appId. ++ * @member {string} appId ++ * @memberof AppAction ++ * @instance ++ */ ++ AppAction.prototype.appId = ""; ++ ++ /** ++ * AppAction metadata. ++ * @member {Uint8Array} metadata ++ * @memberof AppAction ++ * @instance ++ */ ++ AppAction.prototype.metadata = $util.newBuffer([]); ++ ++ /** ++ * AppAction rawAction. ++ * @member {Uint8Array} rawAction ++ * @memberof AppAction ++ * @instance ++ */ ++ AppAction.prototype.rawAction = $util.newBuffer([]); ++ ++ /** ++ * AppAction signature. ++ * @member {Uint8Array} signature ++ * @memberof AppAction ++ * @instance ++ */ ++ AppAction.prototype.signature = $util.newBuffer([]); ++ ++ /** ++ * Creates a new AppAction instance using the specified properties. ++ * @function create ++ * @memberof AppAction ++ * @static ++ * @param {IAppAction=} [properties] Properties to set ++ * @returns {AppAction} AppAction instance ++ */ ++ AppAction.create = function create(properties) { ++ return new AppAction(properties); ++ }; ++ ++ /** ++ * Encodes the specified AppAction message. Does not implicitly {@link AppAction.verify|verify} messages. ++ * @function encode ++ * @memberof AppAction ++ * @static ++ * @param {IAppAction} message AppAction message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ AppAction.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.metadata != null && Object.hasOwnProperty.call(message, "metadata")) ++ writer.uint32(/* id 2, wireType 2 =*/18).bytes(message.metadata); ++ if (message.rawAction != null && Object.hasOwnProperty.call(message, "rawAction")) ++ writer.uint32(/* id 3, wireType 2 =*/26).bytes(message.rawAction); ++ if (message.signature != null && Object.hasOwnProperty.call(message, "signature")) ++ writer.uint32(/* id 4, wireType 2 =*/34).bytes(message.signature); ++ writer.uint32(/* id 999, wireType 2 =*/7994).string(message.appId); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified AppAction message, length delimited. Does not implicitly {@link AppAction.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof AppAction ++ * @static ++ * @param {IAppAction} message AppAction message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ AppAction.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes an AppAction message from the specified reader or buffer. ++ * @function decode ++ * @memberof AppAction ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {AppAction} AppAction ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ AppAction.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.AppAction(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 999: ++ message.appId = reader.string(); ++ break; ++ case 2: ++ message.metadata = reader.bytes(); ++ break; ++ case 3: ++ message.rawAction = reader.bytes(); ++ break; ++ case 4: ++ message.signature = reader.bytes(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ if (!message.hasOwnProperty("appId")) ++ throw $util.ProtocolError("missing required 'appId'", { instance: message }); ++ return message; ++ }; ++ ++ /** ++ * Decodes an AppAction message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof AppAction ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {AppAction} AppAction ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ AppAction.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies an AppAction message. ++ * @function verify ++ * @memberof AppAction ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ AppAction.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (!$util.isString(message.appId)) ++ return "appId: string expected"; ++ if (message.metadata != null && message.hasOwnProperty("metadata")) ++ if (!(message.metadata && typeof message.metadata.length === "number" || $util.isString(message.metadata))) ++ return "metadata: buffer expected"; ++ if (message.rawAction != null && message.hasOwnProperty("rawAction")) ++ if (!(message.rawAction && typeof message.rawAction.length === "number" || $util.isString(message.rawAction))) ++ return "rawAction: buffer expected"; ++ if (message.signature != null && message.hasOwnProperty("signature")) ++ if (!(message.signature && typeof message.signature.length === "number" || $util.isString(message.signature))) ++ return "signature: buffer expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates an AppAction message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof AppAction ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {AppAction} AppAction ++ */ ++ AppAction.fromObject = function fromObject(object) { ++ if (object instanceof $root.AppAction) ++ return object; ++ var message = new $root.AppAction(); ++ if (object.appId != null) ++ message.appId = String(object.appId); ++ if (object.metadata != null) ++ if (typeof object.metadata === "string") ++ $util.base64.decode(object.metadata, message.metadata = $util.newBuffer($util.base64.length(object.metadata)), 0); ++ else if (object.metadata.length) ++ message.metadata = object.metadata; ++ if (object.rawAction != null) ++ if (typeof object.rawAction === "string") ++ $util.base64.decode(object.rawAction, message.rawAction = $util.newBuffer($util.base64.length(object.rawAction)), 0); ++ else if (object.rawAction.length) ++ message.rawAction = object.rawAction; ++ if (object.signature != null) ++ if (typeof object.signature === "string") ++ $util.base64.decode(object.signature, message.signature = $util.newBuffer($util.base64.length(object.signature)), 0); ++ else if (object.signature.length) ++ message.signature = object.signature; ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from an AppAction message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof AppAction ++ * @static ++ * @param {AppAction} message AppAction ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ AppAction.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ if (options.bytes === String) ++ object.metadata = ""; ++ else { ++ object.metadata = []; ++ if (options.bytes !== Array) ++ object.metadata = $util.newBuffer(object.metadata); ++ } ++ if (options.bytes === String) ++ object.rawAction = ""; ++ else { ++ object.rawAction = []; ++ if (options.bytes !== Array) ++ object.rawAction = $util.newBuffer(object.rawAction); ++ } ++ if (options.bytes === String) ++ object.signature = ""; ++ else { ++ object.signature = []; ++ if (options.bytes !== Array) ++ object.signature = $util.newBuffer(object.signature); ++ } ++ object.appId = ""; ++ } ++ if (message.metadata != null && message.hasOwnProperty("metadata")) ++ object.metadata = options.bytes === String ? $util.base64.encode(message.metadata, 0, message.metadata.length) : options.bytes === Array ? Array.prototype.slice.call(message.metadata) : message.metadata; ++ if (message.rawAction != null && message.hasOwnProperty("rawAction")) ++ object.rawAction = options.bytes === String ? $util.base64.encode(message.rawAction, 0, message.rawAction.length) : options.bytes === Array ? Array.prototype.slice.call(message.rawAction) : message.rawAction; ++ if (message.signature != null && message.hasOwnProperty("signature")) ++ object.signature = options.bytes === String ? $util.base64.encode(message.signature, 0, message.signature.length) : options.bytes === Array ? Array.prototype.slice.call(message.signature) : message.signature; ++ if (message.appId != null && message.hasOwnProperty("appId")) ++ object.appId = message.appId; ++ return object; ++ }; ++ ++ /** ++ * Converts this AppAction to JSON. ++ * @function toJSON ++ * @memberof AppAction ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ AppAction.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ /** ++ * ActionType enum. ++ * @name AppAction.ActionType ++ * @enum {number} ++ * @property {number} CREATE_VIDEO=0 CREATE_VIDEO value ++ * @property {number} CREATE_CHANNEL=1 CREATE_CHANNEL value ++ */ ++ AppAction.ActionType = (function() { ++ var valuesById = {}, values = Object.create(valuesById); ++ values[valuesById[0] = "CREATE_VIDEO"] = 0; ++ values[valuesById[1] = "CREATE_CHANNEL"] = 1; ++ return values; ++ })(); ++ ++ /** ++ * CreatorType enum. ++ * @name AppAction.CreatorType ++ * @enum {number} ++ * @property {number} CHANNEL=0 CHANNEL value ++ * @property {number} MEMBER=1 MEMBER value ++ * @property {number} CURATOR_GROUP=2 CURATOR_GROUP value ++ */ ++ AppAction.CreatorType = (function() { ++ var valuesById = {}, values = Object.create(valuesById); ++ values[valuesById[0] = "CHANNEL"] = 0; ++ values[valuesById[1] = "MEMBER"] = 1; ++ values[valuesById[2] = "CURATOR_GROUP"] = 2; ++ return values; ++ })(); ++ ++ return AppAction; ++})(); ++ ++$root.BountyMetadata = (function() { ++ ++ /** ++ * Properties of a BountyMetadata. ++ * @exports IBountyMetadata ++ * @interface IBountyMetadata ++ * @property {string|null} [title] BountyMetadata title ++ * @property {string|null} [description] BountyMetadata description ++ * @property {Long|null} [discussionThread] BountyMetadata discussionThread ++ * @property {string|null} [bannerImageUri] BountyMetadata bannerImageUri ++ */ ++ ++ /** ++ * Constructs a new BountyMetadata. ++ * @exports BountyMetadata ++ * @classdesc Represents a BountyMetadata. ++ * @implements IBountyMetadata ++ * @constructor ++ * @param {IBountyMetadata=} [properties] Properties to set ++ */ ++ function BountyMetadata(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * BountyMetadata title. ++ * @member {string} title ++ * @memberof BountyMetadata ++ * @instance ++ */ ++ BountyMetadata.prototype.title = ""; ++ ++ /** ++ * BountyMetadata description. ++ * @member {string} description ++ * @memberof BountyMetadata ++ * @instance ++ */ ++ BountyMetadata.prototype.description = ""; ++ ++ /** ++ * BountyMetadata discussionThread. ++ * @member {Long} discussionThread ++ * @memberof BountyMetadata ++ * @instance ++ */ ++ BountyMetadata.prototype.discussionThread = $util.Long ? $util.Long.fromBits(0,0,true) : 0; ++ ++ /** ++ * BountyMetadata bannerImageUri. ++ * @member {string} bannerImageUri ++ * @memberof BountyMetadata ++ * @instance ++ */ ++ BountyMetadata.prototype.bannerImageUri = ""; ++ ++ /** ++ * Creates a new BountyMetadata instance using the specified properties. ++ * @function create ++ * @memberof BountyMetadata ++ * @static ++ * @param {IBountyMetadata=} [properties] Properties to set ++ * @returns {BountyMetadata} BountyMetadata instance ++ */ ++ BountyMetadata.create = function create(properties) { ++ return new BountyMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified BountyMetadata message. Does not implicitly {@link BountyMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof BountyMetadata ++ * @static ++ * @param {IBountyMetadata} message BountyMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ BountyMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.title != null && Object.hasOwnProperty.call(message, "title")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.title); ++ if (message.description != null && Object.hasOwnProperty.call(message, "description")) ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.description); ++ if (message.discussionThread != null && Object.hasOwnProperty.call(message, "discussionThread")) ++ writer.uint32(/* id 3, wireType 0 =*/24).uint64(message.discussionThread); ++ if (message.bannerImageUri != null && Object.hasOwnProperty.call(message, "bannerImageUri")) ++ writer.uint32(/* id 4, wireType 2 =*/34).string(message.bannerImageUri); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified BountyMetadata message, length delimited. Does not implicitly {@link BountyMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof BountyMetadata ++ * @static ++ * @param {IBountyMetadata} message BountyMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ BountyMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a BountyMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof BountyMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {BountyMetadata} BountyMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ BountyMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.BountyMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.title = reader.string(); ++ break; ++ case 2: ++ message.description = reader.string(); ++ break; ++ case 3: ++ message.discussionThread = reader.uint64(); ++ break; ++ case 4: ++ message.bannerImageUri = reader.string(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a BountyMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof BountyMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {BountyMetadata} BountyMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ BountyMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a BountyMetadata message. ++ * @function verify ++ * @memberof BountyMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ BountyMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.title != null && message.hasOwnProperty("title")) ++ if (!$util.isString(message.title)) ++ return "title: string expected"; ++ if (message.description != null && message.hasOwnProperty("description")) ++ if (!$util.isString(message.description)) ++ return "description: string expected"; ++ if (message.discussionThread != null && message.hasOwnProperty("discussionThread")) ++ if (!$util.isInteger(message.discussionThread) && !(message.discussionThread && $util.isInteger(message.discussionThread.low) && $util.isInteger(message.discussionThread.high))) ++ return "discussionThread: integer|Long expected"; ++ if (message.bannerImageUri != null && message.hasOwnProperty("bannerImageUri")) ++ if (!$util.isString(message.bannerImageUri)) ++ return "bannerImageUri: string expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a BountyMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof BountyMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {BountyMetadata} BountyMetadata ++ */ ++ BountyMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.BountyMetadata) ++ return object; ++ var message = new $root.BountyMetadata(); ++ if (object.title != null) ++ message.title = String(object.title); ++ if (object.description != null) ++ message.description = String(object.description); ++ if (object.discussionThread != null) ++ if ($util.Long) ++ (message.discussionThread = $util.Long.fromValue(object.discussionThread)).unsigned = true; ++ else if (typeof object.discussionThread === "string") ++ message.discussionThread = parseInt(object.discussionThread, 10); ++ else if (typeof object.discussionThread === "number") ++ message.discussionThread = object.discussionThread; ++ else if (typeof object.discussionThread === "object") ++ message.discussionThread = new $util.LongBits(object.discussionThread.low >>> 0, object.discussionThread.high >>> 0).toNumber(true); ++ if (object.bannerImageUri != null) ++ message.bannerImageUri = String(object.bannerImageUri); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a BountyMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof BountyMetadata ++ * @static ++ * @param {BountyMetadata} message BountyMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ BountyMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.title = ""; ++ object.description = ""; ++ if ($util.Long) { ++ var long = new $util.Long(0, 0, true); ++ object.discussionThread = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; ++ } else ++ object.discussionThread = options.longs === String ? "0" : 0; ++ object.bannerImageUri = ""; ++ } ++ if (message.title != null && message.hasOwnProperty("title")) ++ object.title = message.title; ++ if (message.description != null && message.hasOwnProperty("description")) ++ object.description = message.description; ++ if (message.discussionThread != null && message.hasOwnProperty("discussionThread")) ++ if (typeof message.discussionThread === "number") ++ object.discussionThread = options.longs === String ? String(message.discussionThread) : message.discussionThread; ++ else ++ object.discussionThread = options.longs === String ? $util.Long.prototype.toString.call(message.discussionThread) : options.longs === Number ? new $util.LongBits(message.discussionThread.low >>> 0, message.discussionThread.high >>> 0).toNumber(true) : message.discussionThread; ++ if (message.bannerImageUri != null && message.hasOwnProperty("bannerImageUri")) ++ object.bannerImageUri = message.bannerImageUri; ++ return object; ++ }; ++ ++ /** ++ * Converts this BountyMetadata to JSON. ++ * @function toJSON ++ * @memberof BountyMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ BountyMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return BountyMetadata; ++})(); ++ ++$root.BountyWorkData = (function() { ++ ++ /** ++ * Properties of a BountyWorkData. ++ * @exports IBountyWorkData ++ * @interface IBountyWorkData ++ * @property {string|null} [title] BountyWorkData title ++ * @property {string|null} [description] BountyWorkData description ++ */ ++ ++ /** ++ * Constructs a new BountyWorkData. ++ * @exports BountyWorkData ++ * @classdesc Represents a BountyWorkData. ++ * @implements IBountyWorkData ++ * @constructor ++ * @param {IBountyWorkData=} [properties] Properties to set ++ */ ++ function BountyWorkData(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * BountyWorkData title. ++ * @member {string} title ++ * @memberof BountyWorkData ++ * @instance ++ */ ++ BountyWorkData.prototype.title = ""; ++ ++ /** ++ * BountyWorkData description. ++ * @member {string} description ++ * @memberof BountyWorkData ++ * @instance ++ */ ++ BountyWorkData.prototype.description = ""; ++ ++ /** ++ * Creates a new BountyWorkData instance using the specified properties. ++ * @function create ++ * @memberof BountyWorkData ++ * @static ++ * @param {IBountyWorkData=} [properties] Properties to set ++ * @returns {BountyWorkData} BountyWorkData instance ++ */ ++ BountyWorkData.create = function create(properties) { ++ return new BountyWorkData(properties); ++ }; ++ ++ /** ++ * Encodes the specified BountyWorkData message. Does not implicitly {@link BountyWorkData.verify|verify} messages. ++ * @function encode ++ * @memberof BountyWorkData ++ * @static ++ * @param {IBountyWorkData} message BountyWorkData message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ BountyWorkData.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.title != null && Object.hasOwnProperty.call(message, "title")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.title); ++ if (message.description != null && Object.hasOwnProperty.call(message, "description")) ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.description); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified BountyWorkData message, length delimited. Does not implicitly {@link BountyWorkData.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof BountyWorkData ++ * @static ++ * @param {IBountyWorkData} message BountyWorkData message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ BountyWorkData.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a BountyWorkData message from the specified reader or buffer. ++ * @function decode ++ * @memberof BountyWorkData ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {BountyWorkData} BountyWorkData ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ BountyWorkData.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.BountyWorkData(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.title = reader.string(); ++ break; ++ case 2: ++ message.description = reader.string(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a BountyWorkData message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof BountyWorkData ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {BountyWorkData} BountyWorkData ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ BountyWorkData.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a BountyWorkData message. ++ * @function verify ++ * @memberof BountyWorkData ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ BountyWorkData.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.title != null && message.hasOwnProperty("title")) ++ if (!$util.isString(message.title)) ++ return "title: string expected"; ++ if (message.description != null && message.hasOwnProperty("description")) ++ if (!$util.isString(message.description)) ++ return "description: string expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a BountyWorkData message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof BountyWorkData ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {BountyWorkData} BountyWorkData ++ */ ++ BountyWorkData.fromObject = function fromObject(object) { ++ if (object instanceof $root.BountyWorkData) ++ return object; ++ var message = new $root.BountyWorkData(); ++ if (object.title != null) ++ message.title = String(object.title); ++ if (object.description != null) ++ message.description = String(object.description); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a BountyWorkData message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof BountyWorkData ++ * @static ++ * @param {BountyWorkData} message BountyWorkData ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ BountyWorkData.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.title = ""; ++ object.description = ""; ++ } ++ if (message.title != null && message.hasOwnProperty("title")) ++ object.title = message.title; ++ if (message.description != null && message.hasOwnProperty("description")) ++ object.description = message.description; ++ return object; ++ }; ++ ++ /** ++ * Converts this BountyWorkData to JSON. ++ * @function toJSON ++ * @memberof BountyWorkData ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ BountyWorkData.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return BountyWorkData; ++})(); ++ ++$root.ChannelMetadata = (function() { ++ ++ /** ++ * Properties of a ChannelMetadata. ++ * @exports IChannelMetadata ++ * @interface IChannelMetadata ++ * @property {string|null} [title] ChannelMetadata title ++ * @property {string|null} [description] ChannelMetadata description ++ * @property {boolean|null} [isPublic] ChannelMetadata isPublic ++ * @property {string|null} [language] ChannelMetadata language ++ * @property {number|null} [coverPhoto] ChannelMetadata coverPhoto ++ * @property {number|null} [avatarPhoto] ChannelMetadata avatarPhoto ++ */ ++ ++ /** ++ * Constructs a new ChannelMetadata. ++ * @exports ChannelMetadata ++ * @classdesc Represents a ChannelMetadata. ++ * @implements IChannelMetadata ++ * @constructor ++ * @param {IChannelMetadata=} [properties] Properties to set ++ */ ++ function ChannelMetadata(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * ChannelMetadata title. ++ * @member {string} title ++ * @memberof ChannelMetadata ++ * @instance ++ */ ++ ChannelMetadata.prototype.title = ""; ++ ++ /** ++ * ChannelMetadata description. ++ * @member {string} description ++ * @memberof ChannelMetadata ++ * @instance ++ */ ++ ChannelMetadata.prototype.description = ""; ++ ++ /** ++ * ChannelMetadata isPublic. ++ * @member {boolean} isPublic ++ * @memberof ChannelMetadata ++ * @instance ++ */ ++ ChannelMetadata.prototype.isPublic = false; ++ ++ /** ++ * ChannelMetadata language. ++ * @member {string} language ++ * @memberof ChannelMetadata ++ * @instance ++ */ ++ ChannelMetadata.prototype.language = ""; ++ ++ /** ++ * ChannelMetadata coverPhoto. ++ * @member {number} coverPhoto ++ * @memberof ChannelMetadata ++ * @instance ++ */ ++ ChannelMetadata.prototype.coverPhoto = 0; ++ ++ /** ++ * ChannelMetadata avatarPhoto. ++ * @member {number} avatarPhoto ++ * @memberof ChannelMetadata ++ * @instance ++ */ ++ ChannelMetadata.prototype.avatarPhoto = 0; ++ ++ /** ++ * Creates a new ChannelMetadata instance using the specified properties. ++ * @function create ++ * @memberof ChannelMetadata ++ * @static ++ * @param {IChannelMetadata=} [properties] Properties to set ++ * @returns {ChannelMetadata} ChannelMetadata instance ++ */ ++ ChannelMetadata.create = function create(properties) { ++ return new ChannelMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified ChannelMetadata message. Does not implicitly {@link ChannelMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof ChannelMetadata ++ * @static ++ * @param {IChannelMetadata} message ChannelMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ChannelMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.title != null && Object.hasOwnProperty.call(message, "title")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.title); ++ if (message.description != null && Object.hasOwnProperty.call(message, "description")) ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.description); ++ if (message.isPublic != null && Object.hasOwnProperty.call(message, "isPublic")) ++ writer.uint32(/* id 3, wireType 0 =*/24).bool(message.isPublic); ++ if (message.language != null && Object.hasOwnProperty.call(message, "language")) ++ writer.uint32(/* id 4, wireType 2 =*/34).string(message.language); ++ if (message.coverPhoto != null && Object.hasOwnProperty.call(message, "coverPhoto")) ++ writer.uint32(/* id 5, wireType 0 =*/40).uint32(message.coverPhoto); ++ if (message.avatarPhoto != null && Object.hasOwnProperty.call(message, "avatarPhoto")) ++ writer.uint32(/* id 6, wireType 0 =*/48).uint32(message.avatarPhoto); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified ChannelMetadata message, length delimited. Does not implicitly {@link ChannelMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof ChannelMetadata ++ * @static ++ * @param {IChannelMetadata} message ChannelMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ChannelMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a ChannelMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof ChannelMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {ChannelMetadata} ChannelMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ChannelMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ChannelMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.title = reader.string(); ++ break; ++ case 2: ++ message.description = reader.string(); ++ break; ++ case 3: ++ message.isPublic = reader.bool(); ++ break; ++ case 4: ++ message.language = reader.string(); ++ break; ++ case 5: ++ message.coverPhoto = reader.uint32(); ++ break; ++ case 6: ++ message.avatarPhoto = reader.uint32(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a ChannelMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof ChannelMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {ChannelMetadata} ChannelMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ChannelMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a ChannelMetadata message. ++ * @function verify ++ * @memberof ChannelMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ ChannelMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.title != null && message.hasOwnProperty("title")) ++ if (!$util.isString(message.title)) ++ return "title: string expected"; ++ if (message.description != null && message.hasOwnProperty("description")) ++ if (!$util.isString(message.description)) ++ return "description: string expected"; ++ if (message.isPublic != null && message.hasOwnProperty("isPublic")) ++ if (typeof message.isPublic !== "boolean") ++ return "isPublic: boolean expected"; ++ if (message.language != null && message.hasOwnProperty("language")) ++ if (!$util.isString(message.language)) ++ return "language: string expected"; ++ if (message.coverPhoto != null && message.hasOwnProperty("coverPhoto")) ++ if (!$util.isInteger(message.coverPhoto)) ++ return "coverPhoto: integer expected"; ++ if (message.avatarPhoto != null && message.hasOwnProperty("avatarPhoto")) ++ if (!$util.isInteger(message.avatarPhoto)) ++ return "avatarPhoto: integer expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a ChannelMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof ChannelMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {ChannelMetadata} ChannelMetadata ++ */ ++ ChannelMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.ChannelMetadata) ++ return object; ++ var message = new $root.ChannelMetadata(); ++ if (object.title != null) ++ message.title = String(object.title); ++ if (object.description != null) ++ message.description = String(object.description); ++ if (object.isPublic != null) ++ message.isPublic = Boolean(object.isPublic); ++ if (object.language != null) ++ message.language = String(object.language); ++ if (object.coverPhoto != null) ++ message.coverPhoto = object.coverPhoto >>> 0; ++ if (object.avatarPhoto != null) ++ message.avatarPhoto = object.avatarPhoto >>> 0; ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a ChannelMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof ChannelMetadata ++ * @static ++ * @param {ChannelMetadata} message ChannelMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ ChannelMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.title = ""; ++ object.description = ""; ++ object.isPublic = false; ++ object.language = ""; ++ object.coverPhoto = 0; ++ object.avatarPhoto = 0; ++ } ++ if (message.title != null && message.hasOwnProperty("title")) ++ object.title = message.title; ++ if (message.description != null && message.hasOwnProperty("description")) ++ object.description = message.description; ++ if (message.isPublic != null && message.hasOwnProperty("isPublic")) ++ object.isPublic = message.isPublic; ++ if (message.language != null && message.hasOwnProperty("language")) ++ object.language = message.language; ++ if (message.coverPhoto != null && message.hasOwnProperty("coverPhoto")) ++ object.coverPhoto = message.coverPhoto; ++ if (message.avatarPhoto != null && message.hasOwnProperty("avatarPhoto")) ++ object.avatarPhoto = message.avatarPhoto; ++ return object; ++ }; ++ ++ /** ++ * Converts this ChannelMetadata to JSON. ++ * @function toJSON ++ * @memberof ChannelMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ ChannelMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return ChannelMetadata; ++})(); ++ ++$root.ChannelPayoutsMetadata = (function() { ++ ++ /** ++ * Properties of a ChannelPayoutsMetadata. ++ * @exports IChannelPayoutsMetadata ++ * @interface IChannelPayoutsMetadata ++ * @property {ChannelPayoutsMetadata.IHeader} header ChannelPayoutsMetadata header ++ * @property {ChannelPayoutsMetadata.IBody} body ChannelPayoutsMetadata body ++ */ ++ ++ /** ++ * Constructs a new ChannelPayoutsMetadata. ++ * @exports ChannelPayoutsMetadata ++ * @classdesc Represents a ChannelPayoutsMetadata. ++ * @implements IChannelPayoutsMetadata ++ * @constructor ++ * @param {IChannelPayoutsMetadata=} [properties] Properties to set ++ */ ++ function ChannelPayoutsMetadata(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * ChannelPayoutsMetadata header. ++ * @member {ChannelPayoutsMetadata.IHeader} header ++ * @memberof ChannelPayoutsMetadata ++ * @instance ++ */ ++ ChannelPayoutsMetadata.prototype.header = null; ++ ++ /** ++ * ChannelPayoutsMetadata body. ++ * @member {ChannelPayoutsMetadata.IBody} body ++ * @memberof ChannelPayoutsMetadata ++ * @instance ++ */ ++ ChannelPayoutsMetadata.prototype.body = null; ++ ++ /** ++ * Creates a new ChannelPayoutsMetadata instance using the specified properties. ++ * @function create ++ * @memberof ChannelPayoutsMetadata ++ * @static ++ * @param {IChannelPayoutsMetadata=} [properties] Properties to set ++ * @returns {ChannelPayoutsMetadata} ChannelPayoutsMetadata instance ++ */ ++ ChannelPayoutsMetadata.create = function create(properties) { ++ return new ChannelPayoutsMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified ChannelPayoutsMetadata message. Does not implicitly {@link ChannelPayoutsMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof ChannelPayoutsMetadata ++ * @static ++ * @param {IChannelPayoutsMetadata} message ChannelPayoutsMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ChannelPayoutsMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ $root.ChannelPayoutsMetadata.Header.encode(message.header, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); ++ $root.ChannelPayoutsMetadata.Body.encode(message.body, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified ChannelPayoutsMetadata message, length delimited. Does not implicitly {@link ChannelPayoutsMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof ChannelPayoutsMetadata ++ * @static ++ * @param {IChannelPayoutsMetadata} message ChannelPayoutsMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ChannelPayoutsMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a ChannelPayoutsMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof ChannelPayoutsMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {ChannelPayoutsMetadata} ChannelPayoutsMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ChannelPayoutsMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ChannelPayoutsMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.header = $root.ChannelPayoutsMetadata.Header.decode(reader, reader.uint32()); ++ break; ++ case 2: ++ message.body = $root.ChannelPayoutsMetadata.Body.decode(reader, reader.uint32()); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ if (!message.hasOwnProperty("header")) ++ throw $util.ProtocolError("missing required 'header'", { instance: message }); ++ if (!message.hasOwnProperty("body")) ++ throw $util.ProtocolError("missing required 'body'", { instance: message }); ++ return message; ++ }; ++ ++ /** ++ * Decodes a ChannelPayoutsMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof ChannelPayoutsMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {ChannelPayoutsMetadata} ChannelPayoutsMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ChannelPayoutsMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a ChannelPayoutsMetadata message. ++ * @function verify ++ * @memberof ChannelPayoutsMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ ChannelPayoutsMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ { ++ var error = $root.ChannelPayoutsMetadata.Header.verify(message.header); ++ if (error) ++ return "header." + error; ++ } ++ { ++ var error = $root.ChannelPayoutsMetadata.Body.verify(message.body); ++ if (error) ++ return "body." + error; ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates a ChannelPayoutsMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof ChannelPayoutsMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {ChannelPayoutsMetadata} ChannelPayoutsMetadata ++ */ ++ ChannelPayoutsMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.ChannelPayoutsMetadata) ++ return object; ++ var message = new $root.ChannelPayoutsMetadata(); ++ if (object.header != null) { ++ if (typeof object.header !== "object") ++ throw TypeError(".ChannelPayoutsMetadata.header: object expected"); ++ message.header = $root.ChannelPayoutsMetadata.Header.fromObject(object.header); ++ } ++ if (object.body != null) { ++ if (typeof object.body !== "object") ++ throw TypeError(".ChannelPayoutsMetadata.body: object expected"); ++ message.body = $root.ChannelPayoutsMetadata.Body.fromObject(object.body); ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a ChannelPayoutsMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof ChannelPayoutsMetadata ++ * @static ++ * @param {ChannelPayoutsMetadata} message ChannelPayoutsMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ ChannelPayoutsMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.header = null; ++ object.body = null; ++ } ++ if (message.header != null && message.hasOwnProperty("header")) ++ object.header = $root.ChannelPayoutsMetadata.Header.toObject(message.header, options); ++ if (message.body != null && message.hasOwnProperty("body")) ++ object.body = $root.ChannelPayoutsMetadata.Body.toObject(message.body, options); ++ return object; ++ }; ++ ++ /** ++ * Converts this ChannelPayoutsMetadata to JSON. ++ * @function toJSON ++ * @memberof ChannelPayoutsMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ ChannelPayoutsMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ ChannelPayoutsMetadata.Header = (function() { ++ ++ /** ++ * Properties of a Header. ++ * @memberof ChannelPayoutsMetadata ++ * @interface IHeader ++ * @property {Long} payloadLengthInBytes Header payloadLengthInBytes ++ * @property {Long} headerLengthInBytes Header headerLengthInBytes ++ * @property {number} numberOfChannels Header numberOfChannels ++ * @property {Array.|null} [channelPayoutByteOffsets] Header channelPayoutByteOffsets ++ */ ++ ++ /** ++ * Constructs a new Header. ++ * @memberof ChannelPayoutsMetadata ++ * @classdesc Fields in the payload header are encoded in fixed length 32/64 bits instead of [varint encoding](https://developers.google.com/protocol-buffers/docs/encoding#varints) (uint64/32). ++ * This allows first calculating, and then setting the byte offset of each `ChannelPayoutProof` accurately, e.g. ++ * `byte_offset` = `size(Header)` + `position_where_record_for_channel_exists_in_Body` ++ * If varint encoding is used for header fields, then calculating the byte offset of `ChannelPayoutProof` ++ * w.r.t the start of the payload would be improbable since the header size won't be known. ++ * @implements IHeader ++ * @constructor ++ * @param {ChannelPayoutsMetadata.IHeader=} [properties] Properties to set ++ */ ++ function Header(properties) { ++ this.channelPayoutByteOffsets = []; ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * Header payloadLengthInBytes. ++ * @member {Long} payloadLengthInBytes ++ * @memberof ChannelPayoutsMetadata.Header ++ * @instance ++ */ ++ Header.prototype.payloadLengthInBytes = $util.Long ? $util.Long.fromBits(0,0,false) : 0; ++ ++ /** ++ * Header headerLengthInBytes. ++ * @member {Long} headerLengthInBytes ++ * @memberof ChannelPayoutsMetadata.Header ++ * @instance ++ */ ++ Header.prototype.headerLengthInBytes = $util.Long ? $util.Long.fromBits(0,0,false) : 0; ++ ++ /** ++ * Header numberOfChannels. ++ * @member {number} numberOfChannels ++ * @memberof ChannelPayoutsMetadata.Header ++ * @instance ++ */ ++ Header.prototype.numberOfChannels = 0; ++ ++ /** ++ * Header channelPayoutByteOffsets. ++ * @member {Array.} channelPayoutByteOffsets ++ * @memberof ChannelPayoutsMetadata.Header ++ * @instance ++ */ ++ Header.prototype.channelPayoutByteOffsets = $util.emptyArray; ++ ++ /** ++ * Creates a new Header instance using the specified properties. ++ * @function create ++ * @memberof ChannelPayoutsMetadata.Header ++ * @static ++ * @param {ChannelPayoutsMetadata.IHeader=} [properties] Properties to set ++ * @returns {ChannelPayoutsMetadata.Header} Header instance ++ */ ++ Header.create = function create(properties) { ++ return new Header(properties); ++ }; ++ ++ /** ++ * Encodes the specified Header message. Does not implicitly {@link ChannelPayoutsMetadata.Header.verify|verify} messages. ++ * @function encode ++ * @memberof ChannelPayoutsMetadata.Header ++ * @static ++ * @param {ChannelPayoutsMetadata.IHeader} message Header message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ Header.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ writer.uint32(/* id 1, wireType 1 =*/9).fixed64(message.payloadLengthInBytes); ++ writer.uint32(/* id 2, wireType 1 =*/17).fixed64(message.headerLengthInBytes); ++ writer.uint32(/* id 3, wireType 5 =*/29).fixed32(message.numberOfChannels); ++ if (message.channelPayoutByteOffsets != null && message.channelPayoutByteOffsets.length) ++ for (var i = 0; i < message.channelPayoutByteOffsets.length; ++i) ++ $root.ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset.encode(message.channelPayoutByteOffsets[i], writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim(); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified Header message, length delimited. Does not implicitly {@link ChannelPayoutsMetadata.Header.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof ChannelPayoutsMetadata.Header ++ * @static ++ * @param {ChannelPayoutsMetadata.IHeader} message Header message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ Header.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a Header message from the specified reader or buffer. ++ * @function decode ++ * @memberof ChannelPayoutsMetadata.Header ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {ChannelPayoutsMetadata.Header} Header ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ Header.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ChannelPayoutsMetadata.Header(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.payloadLengthInBytes = reader.fixed64(); ++ break; ++ case 2: ++ message.headerLengthInBytes = reader.fixed64(); ++ break; ++ case 3: ++ message.numberOfChannels = reader.fixed32(); ++ break; ++ case 4: ++ if (!(message.channelPayoutByteOffsets && message.channelPayoutByteOffsets.length)) ++ message.channelPayoutByteOffsets = []; ++ message.channelPayoutByteOffsets.push($root.ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset.decode(reader, reader.uint32())); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ if (!message.hasOwnProperty("payloadLengthInBytes")) ++ throw $util.ProtocolError("missing required 'payloadLengthInBytes'", { instance: message }); ++ if (!message.hasOwnProperty("headerLengthInBytes")) ++ throw $util.ProtocolError("missing required 'headerLengthInBytes'", { instance: message }); ++ if (!message.hasOwnProperty("numberOfChannels")) ++ throw $util.ProtocolError("missing required 'numberOfChannels'", { instance: message }); ++ return message; ++ }; ++ ++ /** ++ * Decodes a Header message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof ChannelPayoutsMetadata.Header ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {ChannelPayoutsMetadata.Header} Header ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ Header.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a Header message. ++ * @function verify ++ * @memberof ChannelPayoutsMetadata.Header ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ Header.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (!$util.isInteger(message.payloadLengthInBytes) && !(message.payloadLengthInBytes && $util.isInteger(message.payloadLengthInBytes.low) && $util.isInteger(message.payloadLengthInBytes.high))) ++ return "payloadLengthInBytes: integer|Long expected"; ++ if (!$util.isInteger(message.headerLengthInBytes) && !(message.headerLengthInBytes && $util.isInteger(message.headerLengthInBytes.low) && $util.isInteger(message.headerLengthInBytes.high))) ++ return "headerLengthInBytes: integer|Long expected"; ++ if (!$util.isInteger(message.numberOfChannels)) ++ return "numberOfChannels: integer expected"; ++ if (message.channelPayoutByteOffsets != null && message.hasOwnProperty("channelPayoutByteOffsets")) { ++ if (!Array.isArray(message.channelPayoutByteOffsets)) ++ return "channelPayoutByteOffsets: array expected"; ++ for (var i = 0; i < message.channelPayoutByteOffsets.length; ++i) { ++ var error = $root.ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset.verify(message.channelPayoutByteOffsets[i]); ++ if (error) ++ return "channelPayoutByteOffsets." + error; ++ } ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates a Header message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof ChannelPayoutsMetadata.Header ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {ChannelPayoutsMetadata.Header} Header ++ */ ++ Header.fromObject = function fromObject(object) { ++ if (object instanceof $root.ChannelPayoutsMetadata.Header) ++ return object; ++ var message = new $root.ChannelPayoutsMetadata.Header(); ++ if (object.payloadLengthInBytes != null) ++ if ($util.Long) ++ (message.payloadLengthInBytes = $util.Long.fromValue(object.payloadLengthInBytes)).unsigned = false; ++ else if (typeof object.payloadLengthInBytes === "string") ++ message.payloadLengthInBytes = parseInt(object.payloadLengthInBytes, 10); ++ else if (typeof object.payloadLengthInBytes === "number") ++ message.payloadLengthInBytes = object.payloadLengthInBytes; ++ else if (typeof object.payloadLengthInBytes === "object") ++ message.payloadLengthInBytes = new $util.LongBits(object.payloadLengthInBytes.low >>> 0, object.payloadLengthInBytes.high >>> 0).toNumber(); ++ if (object.headerLengthInBytes != null) ++ if ($util.Long) ++ (message.headerLengthInBytes = $util.Long.fromValue(object.headerLengthInBytes)).unsigned = false; ++ else if (typeof object.headerLengthInBytes === "string") ++ message.headerLengthInBytes = parseInt(object.headerLengthInBytes, 10); ++ else if (typeof object.headerLengthInBytes === "number") ++ message.headerLengthInBytes = object.headerLengthInBytes; ++ else if (typeof object.headerLengthInBytes === "object") ++ message.headerLengthInBytes = new $util.LongBits(object.headerLengthInBytes.low >>> 0, object.headerLengthInBytes.high >>> 0).toNumber(); ++ if (object.numberOfChannels != null) ++ message.numberOfChannels = object.numberOfChannels >>> 0; ++ if (object.channelPayoutByteOffsets) { ++ if (!Array.isArray(object.channelPayoutByteOffsets)) ++ throw TypeError(".ChannelPayoutsMetadata.Header.channelPayoutByteOffsets: array expected"); ++ message.channelPayoutByteOffsets = []; ++ for (var i = 0; i < object.channelPayoutByteOffsets.length; ++i) { ++ if (typeof object.channelPayoutByteOffsets[i] !== "object") ++ throw TypeError(".ChannelPayoutsMetadata.Header.channelPayoutByteOffsets: object expected"); ++ message.channelPayoutByteOffsets[i] = $root.ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset.fromObject(object.channelPayoutByteOffsets[i]); ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a Header message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof ChannelPayoutsMetadata.Header ++ * @static ++ * @param {ChannelPayoutsMetadata.Header} message Header ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ Header.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.arrays || options.defaults) ++ object.channelPayoutByteOffsets = []; ++ if (options.defaults) { ++ if ($util.Long) { ++ var long = new $util.Long(0, 0, false); ++ object.payloadLengthInBytes = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; ++ } else ++ object.payloadLengthInBytes = options.longs === String ? "0" : 0; ++ if ($util.Long) { ++ var long = new $util.Long(0, 0, false); ++ object.headerLengthInBytes = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; ++ } else ++ object.headerLengthInBytes = options.longs === String ? "0" : 0; ++ object.numberOfChannels = 0; ++ } ++ if (message.payloadLengthInBytes != null && message.hasOwnProperty("payloadLengthInBytes")) ++ if (typeof message.payloadLengthInBytes === "number") ++ object.payloadLengthInBytes = options.longs === String ? String(message.payloadLengthInBytes) : message.payloadLengthInBytes; ++ else ++ object.payloadLengthInBytes = options.longs === String ? $util.Long.prototype.toString.call(message.payloadLengthInBytes) : options.longs === Number ? new $util.LongBits(message.payloadLengthInBytes.low >>> 0, message.payloadLengthInBytes.high >>> 0).toNumber() : message.payloadLengthInBytes; ++ if (message.headerLengthInBytes != null && message.hasOwnProperty("headerLengthInBytes")) ++ if (typeof message.headerLengthInBytes === "number") ++ object.headerLengthInBytes = options.longs === String ? String(message.headerLengthInBytes) : message.headerLengthInBytes; ++ else ++ object.headerLengthInBytes = options.longs === String ? $util.Long.prototype.toString.call(message.headerLengthInBytes) : options.longs === Number ? new $util.LongBits(message.headerLengthInBytes.low >>> 0, message.headerLengthInBytes.high >>> 0).toNumber() : message.headerLengthInBytes; ++ if (message.numberOfChannels != null && message.hasOwnProperty("numberOfChannels")) ++ object.numberOfChannels = message.numberOfChannels; ++ if (message.channelPayoutByteOffsets && message.channelPayoutByteOffsets.length) { ++ object.channelPayoutByteOffsets = []; ++ for (var j = 0; j < message.channelPayoutByteOffsets.length; ++j) ++ object.channelPayoutByteOffsets[j] = $root.ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset.toObject(message.channelPayoutByteOffsets[j], options); ++ } ++ return object; ++ }; ++ ++ /** ++ * Converts this Header to JSON. ++ * @function toJSON ++ * @memberof ChannelPayoutsMetadata.Header ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ Header.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ Header.ChannelPayoutByteOffset = (function() { ++ ++ /** ++ * Properties of a ChannelPayoutByteOffset. ++ * @memberof ChannelPayoutsMetadata.Header ++ * @interface IChannelPayoutByteOffset ++ * @property {number} channelId ChannelPayoutByteOffset channelId ++ * @property {Long} byteOffset ChannelPayoutByteOffset byteOffset ++ */ ++ ++ /** ++ * Constructs a new ChannelPayoutByteOffset. ++ * @memberof ChannelPayoutsMetadata.Header ++ * @classdesc Represents a ChannelPayoutByteOffset. ++ * @implements IChannelPayoutByteOffset ++ * @constructor ++ * @param {ChannelPayoutsMetadata.Header.IChannelPayoutByteOffset=} [properties] Properties to set ++ */ ++ function ChannelPayoutByteOffset(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * ChannelPayoutByteOffset channelId. ++ * @member {number} channelId ++ * @memberof ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset ++ * @instance ++ */ ++ ChannelPayoutByteOffset.prototype.channelId = 0; ++ ++ /** ++ * ChannelPayoutByteOffset byteOffset. ++ * @member {Long} byteOffset ++ * @memberof ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset ++ * @instance ++ */ ++ ChannelPayoutByteOffset.prototype.byteOffset = $util.Long ? $util.Long.fromBits(0,0,false) : 0; ++ ++ /** ++ * Creates a new ChannelPayoutByteOffset instance using the specified properties. ++ * @function create ++ * @memberof ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset ++ * @static ++ * @param {ChannelPayoutsMetadata.Header.IChannelPayoutByteOffset=} [properties] Properties to set ++ * @returns {ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset} ChannelPayoutByteOffset instance ++ */ ++ ChannelPayoutByteOffset.create = function create(properties) { ++ return new ChannelPayoutByteOffset(properties); ++ }; ++ ++ /** ++ * Encodes the specified ChannelPayoutByteOffset message. Does not implicitly {@link ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset.verify|verify} messages. ++ * @function encode ++ * @memberof ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset ++ * @static ++ * @param {ChannelPayoutsMetadata.Header.IChannelPayoutByteOffset} message ChannelPayoutByteOffset message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ChannelPayoutByteOffset.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ writer.uint32(/* id 1, wireType 5 =*/13).fixed32(message.channelId); ++ writer.uint32(/* id 2, wireType 1 =*/17).fixed64(message.byteOffset); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified ChannelPayoutByteOffset message, length delimited. Does not implicitly {@link ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset ++ * @static ++ * @param {ChannelPayoutsMetadata.Header.IChannelPayoutByteOffset} message ChannelPayoutByteOffset message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ChannelPayoutByteOffset.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a ChannelPayoutByteOffset message from the specified reader or buffer. ++ * @function decode ++ * @memberof ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset} ChannelPayoutByteOffset ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ChannelPayoutByteOffset.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.channelId = reader.fixed32(); ++ break; ++ case 2: ++ message.byteOffset = reader.fixed64(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ if (!message.hasOwnProperty("channelId")) ++ throw $util.ProtocolError("missing required 'channelId'", { instance: message }); ++ if (!message.hasOwnProperty("byteOffset")) ++ throw $util.ProtocolError("missing required 'byteOffset'", { instance: message }); ++ return message; ++ }; ++ ++ /** ++ * Decodes a ChannelPayoutByteOffset message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset} ChannelPayoutByteOffset ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ChannelPayoutByteOffset.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a ChannelPayoutByteOffset message. ++ * @function verify ++ * @memberof ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ ChannelPayoutByteOffset.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (!$util.isInteger(message.channelId)) ++ return "channelId: integer expected"; ++ if (!$util.isInteger(message.byteOffset) && !(message.byteOffset && $util.isInteger(message.byteOffset.low) && $util.isInteger(message.byteOffset.high))) ++ return "byteOffset: integer|Long expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a ChannelPayoutByteOffset message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset} ChannelPayoutByteOffset ++ */ ++ ChannelPayoutByteOffset.fromObject = function fromObject(object) { ++ if (object instanceof $root.ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset) ++ return object; ++ var message = new $root.ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset(); ++ if (object.channelId != null) ++ message.channelId = object.channelId >>> 0; ++ if (object.byteOffset != null) ++ if ($util.Long) ++ (message.byteOffset = $util.Long.fromValue(object.byteOffset)).unsigned = false; ++ else if (typeof object.byteOffset === "string") ++ message.byteOffset = parseInt(object.byteOffset, 10); ++ else if (typeof object.byteOffset === "number") ++ message.byteOffset = object.byteOffset; ++ else if (typeof object.byteOffset === "object") ++ message.byteOffset = new $util.LongBits(object.byteOffset.low >>> 0, object.byteOffset.high >>> 0).toNumber(); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a ChannelPayoutByteOffset message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset ++ * @static ++ * @param {ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset} message ChannelPayoutByteOffset ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ ChannelPayoutByteOffset.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.channelId = 0; ++ if ($util.Long) { ++ var long = new $util.Long(0, 0, false); ++ object.byteOffset = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; ++ } else ++ object.byteOffset = options.longs === String ? "0" : 0; ++ } ++ if (message.channelId != null && message.hasOwnProperty("channelId")) ++ object.channelId = message.channelId; ++ if (message.byteOffset != null && message.hasOwnProperty("byteOffset")) ++ if (typeof message.byteOffset === "number") ++ object.byteOffset = options.longs === String ? String(message.byteOffset) : message.byteOffset; ++ else ++ object.byteOffset = options.longs === String ? $util.Long.prototype.toString.call(message.byteOffset) : options.longs === Number ? new $util.LongBits(message.byteOffset.low >>> 0, message.byteOffset.high >>> 0).toNumber() : message.byteOffset; ++ return object; ++ }; ++ ++ /** ++ * Converts this ChannelPayoutByteOffset to JSON. ++ * @function toJSON ++ * @memberof ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ ChannelPayoutByteOffset.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return ChannelPayoutByteOffset; ++ })(); ++ ++ return Header; ++ })(); ++ ++ ChannelPayoutsMetadata.Body = (function() { ++ ++ /** ++ * Properties of a Body. ++ * @memberof ChannelPayoutsMetadata ++ * @interface IBody ++ * @property {Array.|null} [channelPayouts] Body channelPayouts ++ */ ++ ++ /** ++ * Constructs a new Body. ++ * @memberof ChannelPayoutsMetadata ++ * @classdesc Represents a Body. ++ * @implements IBody ++ * @constructor ++ * @param {ChannelPayoutsMetadata.IBody=} [properties] Properties to set ++ */ ++ function Body(properties) { ++ this.channelPayouts = []; ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * Body channelPayouts. ++ * @member {Array.} channelPayouts ++ * @memberof ChannelPayoutsMetadata.Body ++ * @instance ++ */ ++ Body.prototype.channelPayouts = $util.emptyArray; ++ ++ /** ++ * Creates a new Body instance using the specified properties. ++ * @function create ++ * @memberof ChannelPayoutsMetadata.Body ++ * @static ++ * @param {ChannelPayoutsMetadata.IBody=} [properties] Properties to set ++ * @returns {ChannelPayoutsMetadata.Body} Body instance ++ */ ++ Body.create = function create(properties) { ++ return new Body(properties); ++ }; ++ ++ /** ++ * Encodes the specified Body message. Does not implicitly {@link ChannelPayoutsMetadata.Body.verify|verify} messages. ++ * @function encode ++ * @memberof ChannelPayoutsMetadata.Body ++ * @static ++ * @param {ChannelPayoutsMetadata.IBody} message Body message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ Body.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.channelPayouts != null && message.channelPayouts.length) ++ for (var i = 0; i < message.channelPayouts.length; ++i) ++ $root.ChannelPayoutsMetadata.Body.ChannelPayoutProof.encode(message.channelPayouts[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified Body message, length delimited. Does not implicitly {@link ChannelPayoutsMetadata.Body.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof ChannelPayoutsMetadata.Body ++ * @static ++ * @param {ChannelPayoutsMetadata.IBody} message Body message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ Body.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a Body message from the specified reader or buffer. ++ * @function decode ++ * @memberof ChannelPayoutsMetadata.Body ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {ChannelPayoutsMetadata.Body} Body ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ Body.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ChannelPayoutsMetadata.Body(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ if (!(message.channelPayouts && message.channelPayouts.length)) ++ message.channelPayouts = []; ++ message.channelPayouts.push($root.ChannelPayoutsMetadata.Body.ChannelPayoutProof.decode(reader, reader.uint32())); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a Body message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof ChannelPayoutsMetadata.Body ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {ChannelPayoutsMetadata.Body} Body ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ Body.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a Body message. ++ * @function verify ++ * @memberof ChannelPayoutsMetadata.Body ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ Body.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.channelPayouts != null && message.hasOwnProperty("channelPayouts")) { ++ if (!Array.isArray(message.channelPayouts)) ++ return "channelPayouts: array expected"; ++ for (var i = 0; i < message.channelPayouts.length; ++i) { ++ var error = $root.ChannelPayoutsMetadata.Body.ChannelPayoutProof.verify(message.channelPayouts[i]); ++ if (error) ++ return "channelPayouts." + error; ++ } ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates a Body message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof ChannelPayoutsMetadata.Body ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {ChannelPayoutsMetadata.Body} Body ++ */ ++ Body.fromObject = function fromObject(object) { ++ if (object instanceof $root.ChannelPayoutsMetadata.Body) ++ return object; ++ var message = new $root.ChannelPayoutsMetadata.Body(); ++ if (object.channelPayouts) { ++ if (!Array.isArray(object.channelPayouts)) ++ throw TypeError(".ChannelPayoutsMetadata.Body.channelPayouts: array expected"); ++ message.channelPayouts = []; ++ for (var i = 0; i < object.channelPayouts.length; ++i) { ++ if (typeof object.channelPayouts[i] !== "object") ++ throw TypeError(".ChannelPayoutsMetadata.Body.channelPayouts: object expected"); ++ message.channelPayouts[i] = $root.ChannelPayoutsMetadata.Body.ChannelPayoutProof.fromObject(object.channelPayouts[i]); ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a Body message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof ChannelPayoutsMetadata.Body ++ * @static ++ * @param {ChannelPayoutsMetadata.Body} message Body ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ Body.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.arrays || options.defaults) ++ object.channelPayouts = []; ++ if (message.channelPayouts && message.channelPayouts.length) { ++ object.channelPayouts = []; ++ for (var j = 0; j < message.channelPayouts.length; ++j) ++ object.channelPayouts[j] = $root.ChannelPayoutsMetadata.Body.ChannelPayoutProof.toObject(message.channelPayouts[j], options); ++ } ++ return object; ++ }; ++ ++ /** ++ * Converts this Body to JSON. ++ * @function toJSON ++ * @memberof ChannelPayoutsMetadata.Body ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ Body.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ Body.ChannelPayoutProof = (function() { ++ ++ /** ++ * Properties of a ChannelPayoutProof. ++ * @memberof ChannelPayoutsMetadata.Body ++ * @interface IChannelPayoutProof ++ * @property {number} channelId ChannelPayoutProof channelId ++ * @property {string} cumulativeRewardEarned ChannelPayoutProof cumulativeRewardEarned ++ * @property {Array.|null} [merkleBranch] ChannelPayoutProof merkleBranch ++ * @property {string} reason ChannelPayoutProof reason ++ */ ++ ++ /** ++ * Constructs a new ChannelPayoutProof. ++ * @memberof ChannelPayoutsMetadata.Body ++ * @classdesc Represents a ChannelPayoutProof. ++ * @implements IChannelPayoutProof ++ * @constructor ++ * @param {ChannelPayoutsMetadata.Body.IChannelPayoutProof=} [properties] Properties to set ++ */ ++ function ChannelPayoutProof(properties) { ++ this.merkleBranch = []; ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * ChannelPayoutProof channelId. ++ * @member {number} channelId ++ * @memberof ChannelPayoutsMetadata.Body.ChannelPayoutProof ++ * @instance ++ */ ++ ChannelPayoutProof.prototype.channelId = 0; ++ ++ /** ++ * ChannelPayoutProof cumulativeRewardEarned. ++ * @member {string} cumulativeRewardEarned ++ * @memberof ChannelPayoutsMetadata.Body.ChannelPayoutProof ++ * @instance ++ */ ++ ChannelPayoutProof.prototype.cumulativeRewardEarned = ""; ++ ++ /** ++ * ChannelPayoutProof merkleBranch. ++ * @member {Array.} merkleBranch ++ * @memberof ChannelPayoutsMetadata.Body.ChannelPayoutProof ++ * @instance ++ */ ++ ChannelPayoutProof.prototype.merkleBranch = $util.emptyArray; ++ ++ /** ++ * ChannelPayoutProof reason. ++ * @member {string} reason ++ * @memberof ChannelPayoutsMetadata.Body.ChannelPayoutProof ++ * @instance ++ */ ++ ChannelPayoutProof.prototype.reason = ""; ++ ++ /** ++ * Creates a new ChannelPayoutProof instance using the specified properties. ++ * @function create ++ * @memberof ChannelPayoutsMetadata.Body.ChannelPayoutProof ++ * @static ++ * @param {ChannelPayoutsMetadata.Body.IChannelPayoutProof=} [properties] Properties to set ++ * @returns {ChannelPayoutsMetadata.Body.ChannelPayoutProof} ChannelPayoutProof instance ++ */ ++ ChannelPayoutProof.create = function create(properties) { ++ return new ChannelPayoutProof(properties); ++ }; ++ ++ /** ++ * Encodes the specified ChannelPayoutProof message. Does not implicitly {@link ChannelPayoutsMetadata.Body.ChannelPayoutProof.verify|verify} messages. ++ * @function encode ++ * @memberof ChannelPayoutsMetadata.Body.ChannelPayoutProof ++ * @static ++ * @param {ChannelPayoutsMetadata.Body.IChannelPayoutProof} message ChannelPayoutProof message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ChannelPayoutProof.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ writer.uint32(/* id 1, wireType 0 =*/8).uint32(message.channelId); ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.cumulativeRewardEarned); ++ if (message.merkleBranch != null && message.merkleBranch.length) ++ for (var i = 0; i < message.merkleBranch.length; ++i) ++ $root.ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement.encode(message.merkleBranch[i], writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim(); ++ writer.uint32(/* id 4, wireType 2 =*/34).string(message.reason); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified ChannelPayoutProof message, length delimited. Does not implicitly {@link ChannelPayoutsMetadata.Body.ChannelPayoutProof.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof ChannelPayoutsMetadata.Body.ChannelPayoutProof ++ * @static ++ * @param {ChannelPayoutsMetadata.Body.IChannelPayoutProof} message ChannelPayoutProof message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ChannelPayoutProof.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a ChannelPayoutProof message from the specified reader or buffer. ++ * @function decode ++ * @memberof ChannelPayoutsMetadata.Body.ChannelPayoutProof ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {ChannelPayoutsMetadata.Body.ChannelPayoutProof} ChannelPayoutProof ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ChannelPayoutProof.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ChannelPayoutsMetadata.Body.ChannelPayoutProof(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.channelId = reader.uint32(); ++ break; ++ case 2: ++ message.cumulativeRewardEarned = reader.string(); ++ break; ++ case 3: ++ if (!(message.merkleBranch && message.merkleBranch.length)) ++ message.merkleBranch = []; ++ message.merkleBranch.push($root.ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement.decode(reader, reader.uint32())); ++ break; ++ case 4: ++ message.reason = reader.string(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ if (!message.hasOwnProperty("channelId")) ++ throw $util.ProtocolError("missing required 'channelId'", { instance: message }); ++ if (!message.hasOwnProperty("cumulativeRewardEarned")) ++ throw $util.ProtocolError("missing required 'cumulativeRewardEarned'", { instance: message }); ++ if (!message.hasOwnProperty("reason")) ++ throw $util.ProtocolError("missing required 'reason'", { instance: message }); ++ return message; ++ }; ++ ++ /** ++ * Decodes a ChannelPayoutProof message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof ChannelPayoutsMetadata.Body.ChannelPayoutProof ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {ChannelPayoutsMetadata.Body.ChannelPayoutProof} ChannelPayoutProof ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ChannelPayoutProof.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a ChannelPayoutProof message. ++ * @function verify ++ * @memberof ChannelPayoutsMetadata.Body.ChannelPayoutProof ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ ChannelPayoutProof.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (!$util.isInteger(message.channelId)) ++ return "channelId: integer expected"; ++ if (!$util.isString(message.cumulativeRewardEarned)) ++ return "cumulativeRewardEarned: string expected"; ++ if (message.merkleBranch != null && message.hasOwnProperty("merkleBranch")) { ++ if (!Array.isArray(message.merkleBranch)) ++ return "merkleBranch: array expected"; ++ for (var i = 0; i < message.merkleBranch.length; ++i) { ++ var error = $root.ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement.verify(message.merkleBranch[i]); ++ if (error) ++ return "merkleBranch." + error; ++ } ++ } ++ if (!$util.isString(message.reason)) ++ return "reason: string expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a ChannelPayoutProof message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof ChannelPayoutsMetadata.Body.ChannelPayoutProof ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {ChannelPayoutsMetadata.Body.ChannelPayoutProof} ChannelPayoutProof ++ */ ++ ChannelPayoutProof.fromObject = function fromObject(object) { ++ if (object instanceof $root.ChannelPayoutsMetadata.Body.ChannelPayoutProof) ++ return object; ++ var message = new $root.ChannelPayoutsMetadata.Body.ChannelPayoutProof(); ++ if (object.channelId != null) ++ message.channelId = object.channelId >>> 0; ++ if (object.cumulativeRewardEarned != null) ++ message.cumulativeRewardEarned = String(object.cumulativeRewardEarned); ++ if (object.merkleBranch) { ++ if (!Array.isArray(object.merkleBranch)) ++ throw TypeError(".ChannelPayoutsMetadata.Body.ChannelPayoutProof.merkleBranch: array expected"); ++ message.merkleBranch = []; ++ for (var i = 0; i < object.merkleBranch.length; ++i) { ++ if (typeof object.merkleBranch[i] !== "object") ++ throw TypeError(".ChannelPayoutsMetadata.Body.ChannelPayoutProof.merkleBranch: object expected"); ++ message.merkleBranch[i] = $root.ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement.fromObject(object.merkleBranch[i]); ++ } ++ } ++ if (object.reason != null) ++ message.reason = String(object.reason); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a ChannelPayoutProof message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof ChannelPayoutsMetadata.Body.ChannelPayoutProof ++ * @static ++ * @param {ChannelPayoutsMetadata.Body.ChannelPayoutProof} message ChannelPayoutProof ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ ChannelPayoutProof.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.arrays || options.defaults) ++ object.merkleBranch = []; ++ if (options.defaults) { ++ object.channelId = 0; ++ object.cumulativeRewardEarned = ""; ++ object.reason = ""; ++ } ++ if (message.channelId != null && message.hasOwnProperty("channelId")) ++ object.channelId = message.channelId; ++ if (message.cumulativeRewardEarned != null && message.hasOwnProperty("cumulativeRewardEarned")) ++ object.cumulativeRewardEarned = message.cumulativeRewardEarned; ++ if (message.merkleBranch && message.merkleBranch.length) { ++ object.merkleBranch = []; ++ for (var j = 0; j < message.merkleBranch.length; ++j) ++ object.merkleBranch[j] = $root.ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement.toObject(message.merkleBranch[j], options); ++ } ++ if (message.reason != null && message.hasOwnProperty("reason")) ++ object.reason = message.reason; ++ return object; ++ }; ++ ++ /** ++ * Converts this ChannelPayoutProof to JSON. ++ * @function toJSON ++ * @memberof ChannelPayoutsMetadata.Body.ChannelPayoutProof ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ ChannelPayoutProof.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ /** ++ * Side enum. ++ * @name ChannelPayoutsMetadata.Body.ChannelPayoutProof.Side ++ * @enum {number} ++ * @property {number} Left=0 Left value ++ * @property {number} Right=1 Right value ++ */ ++ ChannelPayoutProof.Side = (function() { ++ var valuesById = {}, values = Object.create(valuesById); ++ values[valuesById[0] = "Left"] = 0; ++ values[valuesById[1] = "Right"] = 1; ++ return values; ++ })(); ++ ++ ChannelPayoutProof.ProofElement = (function() { ++ ++ /** ++ * Properties of a ProofElement. ++ * @memberof ChannelPayoutsMetadata.Body.ChannelPayoutProof ++ * @interface IProofElement ++ * @property {string} hash ProofElement hash ++ * @property {ChannelPayoutsMetadata.Body.ChannelPayoutProof.Side} side ProofElement side ++ */ ++ ++ /** ++ * Constructs a new ProofElement. ++ * @memberof ChannelPayoutsMetadata.Body.ChannelPayoutProof ++ * @classdesc Represents a ProofElement. ++ * @implements IProofElement ++ * @constructor ++ * @param {ChannelPayoutsMetadata.Body.ChannelPayoutProof.IProofElement=} [properties] Properties to set ++ */ ++ function ProofElement(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * ProofElement hash. ++ * @member {string} hash ++ * @memberof ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement ++ * @instance ++ */ ++ ProofElement.prototype.hash = ""; ++ ++ /** ++ * ProofElement side. ++ * @member {ChannelPayoutsMetadata.Body.ChannelPayoutProof.Side} side ++ * @memberof ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement ++ * @instance ++ */ ++ ProofElement.prototype.side = 0; ++ ++ /** ++ * Creates a new ProofElement instance using the specified properties. ++ * @function create ++ * @memberof ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement ++ * @static ++ * @param {ChannelPayoutsMetadata.Body.ChannelPayoutProof.IProofElement=} [properties] Properties to set ++ * @returns {ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement} ProofElement instance ++ */ ++ ProofElement.create = function create(properties) { ++ return new ProofElement(properties); ++ }; ++ ++ /** ++ * Encodes the specified ProofElement message. Does not implicitly {@link ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement.verify|verify} messages. ++ * @function encode ++ * @memberof ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement ++ * @static ++ * @param {ChannelPayoutsMetadata.Body.ChannelPayoutProof.IProofElement} message ProofElement message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ProofElement.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.hash); ++ writer.uint32(/* id 2, wireType 0 =*/16).int32(message.side); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified ProofElement message, length delimited. Does not implicitly {@link ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement ++ * @static ++ * @param {ChannelPayoutsMetadata.Body.ChannelPayoutProof.IProofElement} message ProofElement message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ProofElement.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a ProofElement message from the specified reader or buffer. ++ * @function decode ++ * @memberof ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement} ProofElement ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ProofElement.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.hash = reader.string(); ++ break; ++ case 2: ++ message.side = reader.int32(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ if (!message.hasOwnProperty("hash")) ++ throw $util.ProtocolError("missing required 'hash'", { instance: message }); ++ if (!message.hasOwnProperty("side")) ++ throw $util.ProtocolError("missing required 'side'", { instance: message }); ++ return message; ++ }; ++ ++ /** ++ * Decodes a ProofElement message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement} ProofElement ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ProofElement.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a ProofElement message. ++ * @function verify ++ * @memberof ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ ProofElement.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (!$util.isString(message.hash)) ++ return "hash: string expected"; ++ switch (message.side) { ++ default: ++ return "side: enum value expected"; ++ case 0: ++ case 1: ++ break; ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates a ProofElement message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement} ProofElement ++ */ ++ ProofElement.fromObject = function fromObject(object) { ++ if (object instanceof $root.ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement) ++ return object; ++ var message = new $root.ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement(); ++ if (object.hash != null) ++ message.hash = String(object.hash); ++ switch (object.side) { ++ case "Left": ++ case 0: ++ message.side = 0; ++ break; ++ case "Right": ++ case 1: ++ message.side = 1; ++ break; ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a ProofElement message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement ++ * @static ++ * @param {ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement} message ProofElement ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ ProofElement.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.hash = ""; ++ object.side = options.enums === String ? "Left" : 0; ++ } ++ if (message.hash != null && message.hasOwnProperty("hash")) ++ object.hash = message.hash; ++ if (message.side != null && message.hasOwnProperty("side")) ++ object.side = options.enums === String ? $root.ChannelPayoutsMetadata.Body.ChannelPayoutProof.Side[message.side] : message.side; ++ return object; ++ }; ++ ++ /** ++ * Converts this ProofElement to JSON. ++ * @function toJSON ++ * @memberof ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ ProofElement.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return ProofElement; ++ })(); ++ ++ return ChannelPayoutProof; ++ })(); ++ ++ return Body; ++ })(); ++ ++ return ChannelPayoutsMetadata; ++})(); ++ ++$root.CouncilCandidacyNoteMetadata = (function() { ++ ++ /** ++ * Properties of a CouncilCandidacyNoteMetadata. ++ * @exports ICouncilCandidacyNoteMetadata ++ * @interface ICouncilCandidacyNoteMetadata ++ * @property {string|null} [header] CouncilCandidacyNoteMetadata header ++ * @property {Array.|null} [bulletPoints] CouncilCandidacyNoteMetadata bulletPoints ++ * @property {string|null} [bannerImageUri] CouncilCandidacyNoteMetadata bannerImageUri ++ * @property {string|null} [description] CouncilCandidacyNoteMetadata description ++ */ ++ ++ /** ++ * Constructs a new CouncilCandidacyNoteMetadata. ++ * @exports CouncilCandidacyNoteMetadata ++ * @classdesc Represents a CouncilCandidacyNoteMetadata. ++ * @implements ICouncilCandidacyNoteMetadata ++ * @constructor ++ * @param {ICouncilCandidacyNoteMetadata=} [properties] Properties to set ++ */ ++ function CouncilCandidacyNoteMetadata(properties) { ++ this.bulletPoints = []; ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * CouncilCandidacyNoteMetadata header. ++ * @member {string} header ++ * @memberof CouncilCandidacyNoteMetadata ++ * @instance ++ */ ++ CouncilCandidacyNoteMetadata.prototype.header = ""; ++ ++ /** ++ * CouncilCandidacyNoteMetadata bulletPoints. ++ * @member {Array.} bulletPoints ++ * @memberof CouncilCandidacyNoteMetadata ++ * @instance ++ */ ++ CouncilCandidacyNoteMetadata.prototype.bulletPoints = $util.emptyArray; ++ ++ /** ++ * CouncilCandidacyNoteMetadata bannerImageUri. ++ * @member {string} bannerImageUri ++ * @memberof CouncilCandidacyNoteMetadata ++ * @instance ++ */ ++ CouncilCandidacyNoteMetadata.prototype.bannerImageUri = ""; ++ ++ /** ++ * CouncilCandidacyNoteMetadata description. ++ * @member {string} description ++ * @memberof CouncilCandidacyNoteMetadata ++ * @instance ++ */ ++ CouncilCandidacyNoteMetadata.prototype.description = ""; ++ ++ /** ++ * Creates a new CouncilCandidacyNoteMetadata instance using the specified properties. ++ * @function create ++ * @memberof CouncilCandidacyNoteMetadata ++ * @static ++ * @param {ICouncilCandidacyNoteMetadata=} [properties] Properties to set ++ * @returns {CouncilCandidacyNoteMetadata} CouncilCandidacyNoteMetadata instance ++ */ ++ CouncilCandidacyNoteMetadata.create = function create(properties) { ++ return new CouncilCandidacyNoteMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified CouncilCandidacyNoteMetadata message. Does not implicitly {@link CouncilCandidacyNoteMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof CouncilCandidacyNoteMetadata ++ * @static ++ * @param {ICouncilCandidacyNoteMetadata} message CouncilCandidacyNoteMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ CouncilCandidacyNoteMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.header != null && Object.hasOwnProperty.call(message, "header")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.header); ++ if (message.bulletPoints != null && message.bulletPoints.length) ++ for (var i = 0; i < message.bulletPoints.length; ++i) ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.bulletPoints[i]); ++ if (message.bannerImageUri != null && Object.hasOwnProperty.call(message, "bannerImageUri")) ++ writer.uint32(/* id 3, wireType 2 =*/26).string(message.bannerImageUri); ++ if (message.description != null && Object.hasOwnProperty.call(message, "description")) ++ writer.uint32(/* id 4, wireType 2 =*/34).string(message.description); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified CouncilCandidacyNoteMetadata message, length delimited. Does not implicitly {@link CouncilCandidacyNoteMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof CouncilCandidacyNoteMetadata ++ * @static ++ * @param {ICouncilCandidacyNoteMetadata} message CouncilCandidacyNoteMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ CouncilCandidacyNoteMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a CouncilCandidacyNoteMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof CouncilCandidacyNoteMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {CouncilCandidacyNoteMetadata} CouncilCandidacyNoteMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ CouncilCandidacyNoteMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.CouncilCandidacyNoteMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.header = reader.string(); ++ break; ++ case 2: ++ if (!(message.bulletPoints && message.bulletPoints.length)) ++ message.bulletPoints = []; ++ message.bulletPoints.push(reader.string()); ++ break; ++ case 3: ++ message.bannerImageUri = reader.string(); ++ break; ++ case 4: ++ message.description = reader.string(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a CouncilCandidacyNoteMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof CouncilCandidacyNoteMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {CouncilCandidacyNoteMetadata} CouncilCandidacyNoteMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ CouncilCandidacyNoteMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a CouncilCandidacyNoteMetadata message. ++ * @function verify ++ * @memberof CouncilCandidacyNoteMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ CouncilCandidacyNoteMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.header != null && message.hasOwnProperty("header")) ++ if (!$util.isString(message.header)) ++ return "header: string expected"; ++ if (message.bulletPoints != null && message.hasOwnProperty("bulletPoints")) { ++ if (!Array.isArray(message.bulletPoints)) ++ return "bulletPoints: array expected"; ++ for (var i = 0; i < message.bulletPoints.length; ++i) ++ if (!$util.isString(message.bulletPoints[i])) ++ return "bulletPoints: string[] expected"; ++ } ++ if (message.bannerImageUri != null && message.hasOwnProperty("bannerImageUri")) ++ if (!$util.isString(message.bannerImageUri)) ++ return "bannerImageUri: string expected"; ++ if (message.description != null && message.hasOwnProperty("description")) ++ if (!$util.isString(message.description)) ++ return "description: string expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a CouncilCandidacyNoteMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof CouncilCandidacyNoteMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {CouncilCandidacyNoteMetadata} CouncilCandidacyNoteMetadata ++ */ ++ CouncilCandidacyNoteMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.CouncilCandidacyNoteMetadata) ++ return object; ++ var message = new $root.CouncilCandidacyNoteMetadata(); ++ if (object.header != null) ++ message.header = String(object.header); ++ if (object.bulletPoints) { ++ if (!Array.isArray(object.bulletPoints)) ++ throw TypeError(".CouncilCandidacyNoteMetadata.bulletPoints: array expected"); ++ message.bulletPoints = []; ++ for (var i = 0; i < object.bulletPoints.length; ++i) ++ message.bulletPoints[i] = String(object.bulletPoints[i]); ++ } ++ if (object.bannerImageUri != null) ++ message.bannerImageUri = String(object.bannerImageUri); ++ if (object.description != null) ++ message.description = String(object.description); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a CouncilCandidacyNoteMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof CouncilCandidacyNoteMetadata ++ * @static ++ * @param {CouncilCandidacyNoteMetadata} message CouncilCandidacyNoteMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ CouncilCandidacyNoteMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.arrays || options.defaults) ++ object.bulletPoints = []; ++ if (options.defaults) { ++ object.header = ""; ++ object.bannerImageUri = ""; ++ object.description = ""; ++ } ++ if (message.header != null && message.hasOwnProperty("header")) ++ object.header = message.header; ++ if (message.bulletPoints && message.bulletPoints.length) { ++ object.bulletPoints = []; ++ for (var j = 0; j < message.bulletPoints.length; ++j) ++ object.bulletPoints[j] = message.bulletPoints[j]; ++ } ++ if (message.bannerImageUri != null && message.hasOwnProperty("bannerImageUri")) ++ object.bannerImageUri = message.bannerImageUri; ++ if (message.description != null && message.hasOwnProperty("description")) ++ object.description = message.description; ++ return object; ++ }; ++ ++ /** ++ * Converts this CouncilCandidacyNoteMetadata to JSON. ++ * @function toJSON ++ * @memberof CouncilCandidacyNoteMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ CouncilCandidacyNoteMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return CouncilCandidacyNoteMetadata; ++})(); ++ ++$root.ForumPostMetadata = (function() { ++ ++ /** ++ * Properties of a ForumPostMetadata. ++ * @exports IForumPostMetadata ++ * @interface IForumPostMetadata ++ * @property {string|null} [text] ForumPostMetadata text ++ * @property {number|null} [repliesTo] ForumPostMetadata repliesTo ++ */ ++ ++ /** ++ * Constructs a new ForumPostMetadata. ++ * @exports ForumPostMetadata ++ * @classdesc Represents a ForumPostMetadata. ++ * @implements IForumPostMetadata ++ * @constructor ++ * @param {IForumPostMetadata=} [properties] Properties to set ++ */ ++ function ForumPostMetadata(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * ForumPostMetadata text. ++ * @member {string} text ++ * @memberof ForumPostMetadata ++ * @instance ++ */ ++ ForumPostMetadata.prototype.text = ""; ++ ++ /** ++ * ForumPostMetadata repliesTo. ++ * @member {number} repliesTo ++ * @memberof ForumPostMetadata ++ * @instance ++ */ ++ ForumPostMetadata.prototype.repliesTo = 0; ++ ++ /** ++ * Creates a new ForumPostMetadata instance using the specified properties. ++ * @function create ++ * @memberof ForumPostMetadata ++ * @static ++ * @param {IForumPostMetadata=} [properties] Properties to set ++ * @returns {ForumPostMetadata} ForumPostMetadata instance ++ */ ++ ForumPostMetadata.create = function create(properties) { ++ return new ForumPostMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified ForumPostMetadata message. Does not implicitly {@link ForumPostMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof ForumPostMetadata ++ * @static ++ * @param {IForumPostMetadata} message ForumPostMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ForumPostMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.text != null && Object.hasOwnProperty.call(message, "text")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.text); ++ if (message.repliesTo != null && Object.hasOwnProperty.call(message, "repliesTo")) ++ writer.uint32(/* id 2, wireType 0 =*/16).uint32(message.repliesTo); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified ForumPostMetadata message, length delimited. Does not implicitly {@link ForumPostMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof ForumPostMetadata ++ * @static ++ * @param {IForumPostMetadata} message ForumPostMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ForumPostMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a ForumPostMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof ForumPostMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {ForumPostMetadata} ForumPostMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ForumPostMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ForumPostMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.text = reader.string(); ++ break; ++ case 2: ++ message.repliesTo = reader.uint32(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a ForumPostMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof ForumPostMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {ForumPostMetadata} ForumPostMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ForumPostMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a ForumPostMetadata message. ++ * @function verify ++ * @memberof ForumPostMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ ForumPostMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.text != null && message.hasOwnProperty("text")) ++ if (!$util.isString(message.text)) ++ return "text: string expected"; ++ if (message.repliesTo != null && message.hasOwnProperty("repliesTo")) ++ if (!$util.isInteger(message.repliesTo)) ++ return "repliesTo: integer expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a ForumPostMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof ForumPostMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {ForumPostMetadata} ForumPostMetadata ++ */ ++ ForumPostMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.ForumPostMetadata) ++ return object; ++ var message = new $root.ForumPostMetadata(); ++ if (object.text != null) ++ message.text = String(object.text); ++ if (object.repliesTo != null) ++ message.repliesTo = object.repliesTo >>> 0; ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a ForumPostMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof ForumPostMetadata ++ * @static ++ * @param {ForumPostMetadata} message ForumPostMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ ForumPostMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.text = ""; ++ object.repliesTo = 0; ++ } ++ if (message.text != null && message.hasOwnProperty("text")) ++ object.text = message.text; ++ if (message.repliesTo != null && message.hasOwnProperty("repliesTo")) ++ object.repliesTo = message.repliesTo; ++ return object; ++ }; ++ ++ /** ++ * Converts this ForumPostMetadata to JSON. ++ * @function toJSON ++ * @memberof ForumPostMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ ForumPostMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return ForumPostMetadata; ++})(); ++ ++$root.ForumThreadMetadata = (function() { ++ ++ /** ++ * Properties of a ForumThreadMetadata. ++ * @exports IForumThreadMetadata ++ * @interface IForumThreadMetadata ++ * @property {string|null} [title] ForumThreadMetadata title ++ * @property {Array.|null} [tags] ForumThreadMetadata tags ++ */ ++ ++ /** ++ * Constructs a new ForumThreadMetadata. ++ * @exports ForumThreadMetadata ++ * @classdesc Represents a ForumThreadMetadata. ++ * @implements IForumThreadMetadata ++ * @constructor ++ * @param {IForumThreadMetadata=} [properties] Properties to set ++ */ ++ function ForumThreadMetadata(properties) { ++ this.tags = []; ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * ForumThreadMetadata title. ++ * @member {string} title ++ * @memberof ForumThreadMetadata ++ * @instance ++ */ ++ ForumThreadMetadata.prototype.title = ""; ++ ++ /** ++ * ForumThreadMetadata tags. ++ * @member {Array.} tags ++ * @memberof ForumThreadMetadata ++ * @instance ++ */ ++ ForumThreadMetadata.prototype.tags = $util.emptyArray; ++ ++ /** ++ * Creates a new ForumThreadMetadata instance using the specified properties. ++ * @function create ++ * @memberof ForumThreadMetadata ++ * @static ++ * @param {IForumThreadMetadata=} [properties] Properties to set ++ * @returns {ForumThreadMetadata} ForumThreadMetadata instance ++ */ ++ ForumThreadMetadata.create = function create(properties) { ++ return new ForumThreadMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified ForumThreadMetadata message. Does not implicitly {@link ForumThreadMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof ForumThreadMetadata ++ * @static ++ * @param {IForumThreadMetadata} message ForumThreadMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ForumThreadMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.title != null && Object.hasOwnProperty.call(message, "title")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.title); ++ if (message.tags != null && message.tags.length) ++ for (var i = 0; i < message.tags.length; ++i) ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.tags[i]); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified ForumThreadMetadata message, length delimited. Does not implicitly {@link ForumThreadMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof ForumThreadMetadata ++ * @static ++ * @param {IForumThreadMetadata} message ForumThreadMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ForumThreadMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a ForumThreadMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof ForumThreadMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {ForumThreadMetadata} ForumThreadMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ForumThreadMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ForumThreadMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.title = reader.string(); ++ break; ++ case 2: ++ if (!(message.tags && message.tags.length)) ++ message.tags = []; ++ message.tags.push(reader.string()); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a ForumThreadMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof ForumThreadMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {ForumThreadMetadata} ForumThreadMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ForumThreadMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a ForumThreadMetadata message. ++ * @function verify ++ * @memberof ForumThreadMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ ForumThreadMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.title != null && message.hasOwnProperty("title")) ++ if (!$util.isString(message.title)) ++ return "title: string expected"; ++ if (message.tags != null && message.hasOwnProperty("tags")) { ++ if (!Array.isArray(message.tags)) ++ return "tags: array expected"; ++ for (var i = 0; i < message.tags.length; ++i) ++ if (!$util.isString(message.tags[i])) ++ return "tags: string[] expected"; ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates a ForumThreadMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof ForumThreadMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {ForumThreadMetadata} ForumThreadMetadata ++ */ ++ ForumThreadMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.ForumThreadMetadata) ++ return object; ++ var message = new $root.ForumThreadMetadata(); ++ if (object.title != null) ++ message.title = String(object.title); ++ if (object.tags) { ++ if (!Array.isArray(object.tags)) ++ throw TypeError(".ForumThreadMetadata.tags: array expected"); ++ message.tags = []; ++ for (var i = 0; i < object.tags.length; ++i) ++ message.tags[i] = String(object.tags[i]); ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a ForumThreadMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof ForumThreadMetadata ++ * @static ++ * @param {ForumThreadMetadata} message ForumThreadMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ ForumThreadMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.arrays || options.defaults) ++ object.tags = []; ++ if (options.defaults) ++ object.title = ""; ++ if (message.title != null && message.hasOwnProperty("title")) ++ object.title = message.title; ++ if (message.tags && message.tags.length) { ++ object.tags = []; ++ for (var j = 0; j < message.tags.length; ++j) ++ object.tags[j] = message.tags[j]; ++ } ++ return object; ++ }; ++ ++ /** ++ * Converts this ForumThreadMetadata to JSON. ++ * @function toJSON ++ * @memberof ForumThreadMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ ForumThreadMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return ForumThreadMetadata; ++})(); ++ ++$root.MembershipMetadata = (function() { ++ ++ /** ++ * Properties of a MembershipMetadata. ++ * @exports IMembershipMetadata ++ * @interface IMembershipMetadata ++ * @property {string|null} [name] MembershipMetadata name ++ * @property {number|null} [avatarObject] MembershipMetadata avatarObject ++ * @property {string|null} [avatarUri] MembershipMetadata avatarUri ++ * @property {string|null} [about] MembershipMetadata about ++ * @property {Array.|null} [externalResources] MembershipMetadata externalResources ++ */ ++ ++ /** ++ * Constructs a new MembershipMetadata. ++ * @exports MembershipMetadata ++ * @classdesc Represents a MembershipMetadata. ++ * @implements IMembershipMetadata ++ * @constructor ++ * @param {IMembershipMetadata=} [properties] Properties to set ++ */ ++ function MembershipMetadata(properties) { ++ this.externalResources = []; ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * MembershipMetadata name. ++ * @member {string} name ++ * @memberof MembershipMetadata ++ * @instance ++ */ ++ MembershipMetadata.prototype.name = ""; ++ ++ /** ++ * MembershipMetadata avatarObject. ++ * @member {number|null|undefined} avatarObject ++ * @memberof MembershipMetadata ++ * @instance ++ */ ++ MembershipMetadata.prototype.avatarObject = null; ++ ++ /** ++ * MembershipMetadata avatarUri. ++ * @member {string|null|undefined} avatarUri ++ * @memberof MembershipMetadata ++ * @instance ++ */ ++ MembershipMetadata.prototype.avatarUri = null; ++ ++ /** ++ * MembershipMetadata about. ++ * @member {string} about ++ * @memberof MembershipMetadata ++ * @instance ++ */ ++ MembershipMetadata.prototype.about = ""; ++ ++ /** ++ * MembershipMetadata externalResources. ++ * @member {Array.} externalResources ++ * @memberof MembershipMetadata ++ * @instance ++ */ ++ MembershipMetadata.prototype.externalResources = $util.emptyArray; ++ ++ // OneOf field names bound to virtual getters and setters ++ var $oneOfFields; ++ ++ /** ++ * MembershipMetadata avatar. ++ * @member {"avatarObject"|"avatarUri"|undefined} avatar ++ * @memberof MembershipMetadata ++ * @instance ++ */ ++ Object.defineProperty(MembershipMetadata.prototype, "avatar", { ++ get: $util.oneOfGetter($oneOfFields = ["avatarObject", "avatarUri"]), ++ set: $util.oneOfSetter($oneOfFields) ++ }); ++ ++ /** ++ * Creates a new MembershipMetadata instance using the specified properties. ++ * @function create ++ * @memberof MembershipMetadata ++ * @static ++ * @param {IMembershipMetadata=} [properties] Properties to set ++ * @returns {MembershipMetadata} MembershipMetadata instance ++ */ ++ MembershipMetadata.create = function create(properties) { ++ return new MembershipMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified MembershipMetadata message. Does not implicitly {@link MembershipMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof MembershipMetadata ++ * @static ++ * @param {IMembershipMetadata} message MembershipMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ MembershipMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.name != null && Object.hasOwnProperty.call(message, "name")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.name); ++ if (message.avatarObject != null && Object.hasOwnProperty.call(message, "avatarObject")) ++ writer.uint32(/* id 2, wireType 0 =*/16).uint32(message.avatarObject); ++ if (message.about != null && Object.hasOwnProperty.call(message, "about")) ++ writer.uint32(/* id 3, wireType 2 =*/26).string(message.about); ++ if (message.avatarUri != null && Object.hasOwnProperty.call(message, "avatarUri")) ++ writer.uint32(/* id 4, wireType 2 =*/34).string(message.avatarUri); ++ if (message.externalResources != null && message.externalResources.length) ++ for (var i = 0; i < message.externalResources.length; ++i) ++ $root.MembershipMetadata.ExternalResource.encode(message.externalResources[i], writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim(); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified MembershipMetadata message, length delimited. Does not implicitly {@link MembershipMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof MembershipMetadata ++ * @static ++ * @param {IMembershipMetadata} message MembershipMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ MembershipMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a MembershipMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof MembershipMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {MembershipMetadata} MembershipMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ MembershipMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.MembershipMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.name = reader.string(); ++ break; ++ case 2: ++ message.avatarObject = reader.uint32(); ++ break; ++ case 4: ++ message.avatarUri = reader.string(); ++ break; ++ case 3: ++ message.about = reader.string(); ++ break; ++ case 5: ++ if (!(message.externalResources && message.externalResources.length)) ++ message.externalResources = []; ++ message.externalResources.push($root.MembershipMetadata.ExternalResource.decode(reader, reader.uint32())); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a MembershipMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof MembershipMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {MembershipMetadata} MembershipMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ MembershipMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a MembershipMetadata message. ++ * @function verify ++ * @memberof MembershipMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ MembershipMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ var properties = {}; ++ if (message.name != null && message.hasOwnProperty("name")) ++ if (!$util.isString(message.name)) ++ return "name: string expected"; ++ if (message.avatarObject != null && message.hasOwnProperty("avatarObject")) { ++ properties.avatar = 1; ++ if (!$util.isInteger(message.avatarObject)) ++ return "avatarObject: integer expected"; ++ } ++ if (message.avatarUri != null && message.hasOwnProperty("avatarUri")) { ++ if (properties.avatar === 1) ++ return "avatar: multiple values"; ++ properties.avatar = 1; ++ if (!$util.isString(message.avatarUri)) ++ return "avatarUri: string expected"; ++ } ++ if (message.about != null && message.hasOwnProperty("about")) ++ if (!$util.isString(message.about)) ++ return "about: string expected"; ++ if (message.externalResources != null && message.hasOwnProperty("externalResources")) { ++ if (!Array.isArray(message.externalResources)) ++ return "externalResources: array expected"; ++ for (var i = 0; i < message.externalResources.length; ++i) { ++ var error = $root.MembershipMetadata.ExternalResource.verify(message.externalResources[i]); ++ if (error) ++ return "externalResources." + error; ++ } ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates a MembershipMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof MembershipMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {MembershipMetadata} MembershipMetadata ++ */ ++ MembershipMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.MembershipMetadata) ++ return object; ++ var message = new $root.MembershipMetadata(); ++ if (object.name != null) ++ message.name = String(object.name); ++ if (object.avatarObject != null) ++ message.avatarObject = object.avatarObject >>> 0; ++ if (object.avatarUri != null) ++ message.avatarUri = String(object.avatarUri); ++ if (object.about != null) ++ message.about = String(object.about); ++ if (object.externalResources) { ++ if (!Array.isArray(object.externalResources)) ++ throw TypeError(".MembershipMetadata.externalResources: array expected"); ++ message.externalResources = []; ++ for (var i = 0; i < object.externalResources.length; ++i) { ++ if (typeof object.externalResources[i] !== "object") ++ throw TypeError(".MembershipMetadata.externalResources: object expected"); ++ message.externalResources[i] = $root.MembershipMetadata.ExternalResource.fromObject(object.externalResources[i]); ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a MembershipMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof MembershipMetadata ++ * @static ++ * @param {MembershipMetadata} message MembershipMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ MembershipMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.arrays || options.defaults) ++ object.externalResources = []; ++ if (options.defaults) { ++ object.name = ""; ++ object.about = ""; ++ } ++ if (message.name != null && message.hasOwnProperty("name")) ++ object.name = message.name; ++ if (message.avatarObject != null && message.hasOwnProperty("avatarObject")) { ++ object.avatarObject = message.avatarObject; ++ if (options.oneofs) ++ object.avatar = "avatarObject"; ++ } ++ if (message.about != null && message.hasOwnProperty("about")) ++ object.about = message.about; ++ if (message.avatarUri != null && message.hasOwnProperty("avatarUri")) { ++ object.avatarUri = message.avatarUri; ++ if (options.oneofs) ++ object.avatar = "avatarUri"; ++ } ++ if (message.externalResources && message.externalResources.length) { ++ object.externalResources = []; ++ for (var j = 0; j < message.externalResources.length; ++j) ++ object.externalResources[j] = $root.MembershipMetadata.ExternalResource.toObject(message.externalResources[j], options); ++ } ++ return object; ++ }; ++ ++ /** ++ * Converts this MembershipMetadata to JSON. ++ * @function toJSON ++ * @memberof MembershipMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ MembershipMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ MembershipMetadata.ExternalResource = (function() { ++ ++ /** ++ * Properties of an ExternalResource. ++ * @memberof MembershipMetadata ++ * @interface IExternalResource ++ * @property {MembershipMetadata.ExternalResource.ResourceType|null} [type] ExternalResource type ++ * @property {string|null} [value] ExternalResource value ++ */ ++ ++ /** ++ * Constructs a new ExternalResource. ++ * @memberof MembershipMetadata ++ * @classdesc Represents an ExternalResource. ++ * @implements IExternalResource ++ * @constructor ++ * @param {MembershipMetadata.IExternalResource=} [properties] Properties to set ++ */ ++ function ExternalResource(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * ExternalResource type. ++ * @member {MembershipMetadata.ExternalResource.ResourceType} type ++ * @memberof MembershipMetadata.ExternalResource ++ * @instance ++ */ ++ ExternalResource.prototype.type = 0; ++ ++ /** ++ * ExternalResource value. ++ * @member {string} value ++ * @memberof MembershipMetadata.ExternalResource ++ * @instance ++ */ ++ ExternalResource.prototype.value = ""; ++ ++ /** ++ * Creates a new ExternalResource instance using the specified properties. ++ * @function create ++ * @memberof MembershipMetadata.ExternalResource ++ * @static ++ * @param {MembershipMetadata.IExternalResource=} [properties] Properties to set ++ * @returns {MembershipMetadata.ExternalResource} ExternalResource instance ++ */ ++ ExternalResource.create = function create(properties) { ++ return new ExternalResource(properties); ++ }; ++ ++ /** ++ * Encodes the specified ExternalResource message. Does not implicitly {@link MembershipMetadata.ExternalResource.verify|verify} messages. ++ * @function encode ++ * @memberof MembershipMetadata.ExternalResource ++ * @static ++ * @param {MembershipMetadata.IExternalResource} message ExternalResource message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ExternalResource.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.type != null && Object.hasOwnProperty.call(message, "type")) ++ writer.uint32(/* id 1, wireType 0 =*/8).int32(message.type); ++ if (message.value != null && Object.hasOwnProperty.call(message, "value")) ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.value); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified ExternalResource message, length delimited. Does not implicitly {@link MembershipMetadata.ExternalResource.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof MembershipMetadata.ExternalResource ++ * @static ++ * @param {MembershipMetadata.IExternalResource} message ExternalResource message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ExternalResource.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes an ExternalResource message from the specified reader or buffer. ++ * @function decode ++ * @memberof MembershipMetadata.ExternalResource ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {MembershipMetadata.ExternalResource} ExternalResource ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ExternalResource.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.MembershipMetadata.ExternalResource(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.type = reader.int32(); ++ break; ++ case 2: ++ message.value = reader.string(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes an ExternalResource message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof MembershipMetadata.ExternalResource ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {MembershipMetadata.ExternalResource} ExternalResource ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ExternalResource.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies an ExternalResource message. ++ * @function verify ++ * @memberof MembershipMetadata.ExternalResource ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ ExternalResource.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.type != null && message.hasOwnProperty("type")) ++ switch (message.type) { ++ default: ++ return "type: enum value expected"; ++ case 0: ++ case 1: ++ case 2: ++ case 3: ++ case 4: ++ case 5: ++ case 6: ++ case 7: ++ case 8: ++ case 9: ++ case 10: ++ break; ++ } ++ if (message.value != null && message.hasOwnProperty("value")) ++ if (!$util.isString(message.value)) ++ return "value: string expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates an ExternalResource message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof MembershipMetadata.ExternalResource ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {MembershipMetadata.ExternalResource} ExternalResource ++ */ ++ ExternalResource.fromObject = function fromObject(object) { ++ if (object instanceof $root.MembershipMetadata.ExternalResource) ++ return object; ++ var message = new $root.MembershipMetadata.ExternalResource(); ++ switch (object.type) { ++ case "EMAIL": ++ case 0: ++ message.type = 0; ++ break; ++ case "HYPERLINK": ++ case 1: ++ message.type = 1; ++ break; ++ case "TWITTER": ++ case 2: ++ message.type = 2; ++ break; ++ case "TELEGRAM": ++ case 3: ++ message.type = 3; ++ break; ++ case "DISCORD": ++ case 4: ++ message.type = 4; ++ break; ++ case "FACEBOOK": ++ case 5: ++ message.type = 5; ++ break; ++ case "YOUTUBE": ++ case 6: ++ message.type = 6; ++ break; ++ case "MATRIX": ++ case 7: ++ message.type = 7; ++ break; ++ case "IRC": ++ case 8: ++ message.type = 8; ++ break; ++ case "WECHAT": ++ case 9: ++ message.type = 9; ++ break; ++ case "WHATSAPP": ++ case 10: ++ message.type = 10; ++ break; ++ } ++ if (object.value != null) ++ message.value = String(object.value); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from an ExternalResource message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof MembershipMetadata.ExternalResource ++ * @static ++ * @param {MembershipMetadata.ExternalResource} message ExternalResource ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ ExternalResource.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.type = options.enums === String ? "EMAIL" : 0; ++ object.value = ""; ++ } ++ if (message.type != null && message.hasOwnProperty("type")) ++ object.type = options.enums === String ? $root.MembershipMetadata.ExternalResource.ResourceType[message.type] : message.type; ++ if (message.value != null && message.hasOwnProperty("value")) ++ object.value = message.value; ++ return object; ++ }; ++ ++ /** ++ * Converts this ExternalResource to JSON. ++ * @function toJSON ++ * @memberof MembershipMetadata.ExternalResource ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ ExternalResource.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ /** ++ * ResourceType enum. ++ * @name MembershipMetadata.ExternalResource.ResourceType ++ * @enum {number} ++ * @property {number} EMAIL=0 EMAIL value ++ * @property {number} HYPERLINK=1 HYPERLINK value ++ * @property {number} TWITTER=2 TWITTER value ++ * @property {number} TELEGRAM=3 TELEGRAM value ++ * @property {number} DISCORD=4 DISCORD value ++ * @property {number} FACEBOOK=5 FACEBOOK value ++ * @property {number} YOUTUBE=6 YOUTUBE value ++ * @property {number} MATRIX=7 MATRIX value ++ * @property {number} IRC=8 IRC value ++ * @property {number} WECHAT=9 WECHAT value ++ * @property {number} WHATSAPP=10 WHATSAPP value ++ */ ++ ExternalResource.ResourceType = (function() { ++ var valuesById = {}, values = Object.create(valuesById); ++ values[valuesById[0] = "EMAIL"] = 0; ++ values[valuesById[1] = "HYPERLINK"] = 1; ++ values[valuesById[2] = "TWITTER"] = 2; ++ values[valuesById[3] = "TELEGRAM"] = 3; ++ values[valuesById[4] = "DISCORD"] = 4; ++ values[valuesById[5] = "FACEBOOK"] = 5; ++ values[valuesById[6] = "YOUTUBE"] = 6; ++ values[valuesById[7] = "MATRIX"] = 7; ++ values[valuesById[8] = "IRC"] = 8; ++ values[valuesById[9] = "WECHAT"] = 9; ++ values[valuesById[10] = "WHATSAPP"] = 10; ++ return values; ++ })(); ++ ++ return ExternalResource; ++ })(); ++ ++ return MembershipMetadata; ++})(); ++ ++$root.ReactVideo = (function() { ++ ++ /** ++ * Properties of a ReactVideo. ++ * @exports IReactVideo ++ * @interface IReactVideo ++ * @property {Long} videoId ReactVideo videoId ++ * @property {ReactVideo.Reaction} reaction ReactVideo reaction ++ */ ++ ++ /** ++ * Constructs a new ReactVideo. ++ * @exports ReactVideo ++ * @classdesc Represents a ReactVideo. ++ * @implements IReactVideo ++ * @constructor ++ * @param {IReactVideo=} [properties] Properties to set ++ */ ++ function ReactVideo(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * ReactVideo videoId. ++ * @member {Long} videoId ++ * @memberof ReactVideo ++ * @instance ++ */ ++ ReactVideo.prototype.videoId = $util.Long ? $util.Long.fromBits(0,0,true) : 0; ++ ++ /** ++ * ReactVideo reaction. ++ * @member {ReactVideo.Reaction} reaction ++ * @memberof ReactVideo ++ * @instance ++ */ ++ ReactVideo.prototype.reaction = 0; ++ ++ /** ++ * Creates a new ReactVideo instance using the specified properties. ++ * @function create ++ * @memberof ReactVideo ++ * @static ++ * @param {IReactVideo=} [properties] Properties to set ++ * @returns {ReactVideo} ReactVideo instance ++ */ ++ ReactVideo.create = function create(properties) { ++ return new ReactVideo(properties); ++ }; ++ ++ /** ++ * Encodes the specified ReactVideo message. Does not implicitly {@link ReactVideo.verify|verify} messages. ++ * @function encode ++ * @memberof ReactVideo ++ * @static ++ * @param {IReactVideo} message ReactVideo message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ReactVideo.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.videoId); ++ writer.uint32(/* id 2, wireType 0 =*/16).int32(message.reaction); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified ReactVideo message, length delimited. Does not implicitly {@link ReactVideo.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof ReactVideo ++ * @static ++ * @param {IReactVideo} message ReactVideo message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ReactVideo.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a ReactVideo message from the specified reader or buffer. ++ * @function decode ++ * @memberof ReactVideo ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {ReactVideo} ReactVideo ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ReactVideo.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ReactVideo(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.videoId = reader.uint64(); ++ break; ++ case 2: ++ message.reaction = reader.int32(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ if (!message.hasOwnProperty("videoId")) ++ throw $util.ProtocolError("missing required 'videoId'", { instance: message }); ++ if (!message.hasOwnProperty("reaction")) ++ throw $util.ProtocolError("missing required 'reaction'", { instance: message }); ++ return message; ++ }; ++ ++ /** ++ * Decodes a ReactVideo message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof ReactVideo ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {ReactVideo} ReactVideo ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ReactVideo.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a ReactVideo message. ++ * @function verify ++ * @memberof ReactVideo ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ ReactVideo.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (!$util.isInteger(message.videoId) && !(message.videoId && $util.isInteger(message.videoId.low) && $util.isInteger(message.videoId.high))) ++ return "videoId: integer|Long expected"; ++ switch (message.reaction) { ++ default: ++ return "reaction: enum value expected"; ++ case 0: ++ case 1: ++ break; ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates a ReactVideo message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof ReactVideo ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {ReactVideo} ReactVideo ++ */ ++ ReactVideo.fromObject = function fromObject(object) { ++ if (object instanceof $root.ReactVideo) ++ return object; ++ var message = new $root.ReactVideo(); ++ if (object.videoId != null) ++ if ($util.Long) ++ (message.videoId = $util.Long.fromValue(object.videoId)).unsigned = true; ++ else if (typeof object.videoId === "string") ++ message.videoId = parseInt(object.videoId, 10); ++ else if (typeof object.videoId === "number") ++ message.videoId = object.videoId; ++ else if (typeof object.videoId === "object") ++ message.videoId = new $util.LongBits(object.videoId.low >>> 0, object.videoId.high >>> 0).toNumber(true); ++ switch (object.reaction) { ++ case "LIKE": ++ case 0: ++ message.reaction = 0; ++ break; ++ case "UNLIKE": ++ case 1: ++ message.reaction = 1; ++ break; ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a ReactVideo message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof ReactVideo ++ * @static ++ * @param {ReactVideo} message ReactVideo ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ ReactVideo.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ if ($util.Long) { ++ var long = new $util.Long(0, 0, true); ++ object.videoId = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; ++ } else ++ object.videoId = options.longs === String ? "0" : 0; ++ object.reaction = options.enums === String ? "LIKE" : 0; ++ } ++ if (message.videoId != null && message.hasOwnProperty("videoId")) ++ if (typeof message.videoId === "number") ++ object.videoId = options.longs === String ? String(message.videoId) : message.videoId; ++ else ++ object.videoId = options.longs === String ? $util.Long.prototype.toString.call(message.videoId) : options.longs === Number ? new $util.LongBits(message.videoId.low >>> 0, message.videoId.high >>> 0).toNumber(true) : message.videoId; ++ if (message.reaction != null && message.hasOwnProperty("reaction")) ++ object.reaction = options.enums === String ? $root.ReactVideo.Reaction[message.reaction] : message.reaction; ++ return object; ++ }; ++ ++ /** ++ * Converts this ReactVideo to JSON. ++ * @function toJSON ++ * @memberof ReactVideo ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ ReactVideo.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ /** ++ * Reaction enum. ++ * @name ReactVideo.Reaction ++ * @enum {number} ++ * @property {number} LIKE=0 LIKE value ++ * @property {number} UNLIKE=1 UNLIKE value ++ */ ++ ReactVideo.Reaction = (function() { ++ var valuesById = {}, values = Object.create(valuesById); ++ values[valuesById[0] = "LIKE"] = 0; ++ values[valuesById[1] = "UNLIKE"] = 1; ++ return values; ++ })(); ++ ++ return ReactVideo; ++})(); ++ ++$root.ReactComment = (function() { ++ ++ /** ++ * Properties of a ReactComment. ++ * @exports IReactComment ++ * @interface IReactComment ++ * @property {string} commentId ReactComment commentId ++ * @property {number} reactionId ReactComment reactionId ++ */ ++ ++ /** ++ * Constructs a new ReactComment. ++ * @exports ReactComment ++ * @classdesc Represents a ReactComment. ++ * @implements IReactComment ++ * @constructor ++ * @param {IReactComment=} [properties] Properties to set ++ */ ++ function ReactComment(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * ReactComment commentId. ++ * @member {string} commentId ++ * @memberof ReactComment ++ * @instance ++ */ ++ ReactComment.prototype.commentId = ""; ++ ++ /** ++ * ReactComment reactionId. ++ * @member {number} reactionId ++ * @memberof ReactComment ++ * @instance ++ */ ++ ReactComment.prototype.reactionId = 0; ++ ++ /** ++ * Creates a new ReactComment instance using the specified properties. ++ * @function create ++ * @memberof ReactComment ++ * @static ++ * @param {IReactComment=} [properties] Properties to set ++ * @returns {ReactComment} ReactComment instance ++ */ ++ ReactComment.create = function create(properties) { ++ return new ReactComment(properties); ++ }; ++ ++ /** ++ * Encodes the specified ReactComment message. Does not implicitly {@link ReactComment.verify|verify} messages. ++ * @function encode ++ * @memberof ReactComment ++ * @static ++ * @param {IReactComment} message ReactComment message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ReactComment.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.commentId); ++ writer.uint32(/* id 2, wireType 0 =*/16).uint32(message.reactionId); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified ReactComment message, length delimited. Does not implicitly {@link ReactComment.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof ReactComment ++ * @static ++ * @param {IReactComment} message ReactComment message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ReactComment.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a ReactComment message from the specified reader or buffer. ++ * @function decode ++ * @memberof ReactComment ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {ReactComment} ReactComment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ReactComment.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ReactComment(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.commentId = reader.string(); ++ break; ++ case 2: ++ message.reactionId = reader.uint32(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ if (!message.hasOwnProperty("commentId")) ++ throw $util.ProtocolError("missing required 'commentId'", { instance: message }); ++ if (!message.hasOwnProperty("reactionId")) ++ throw $util.ProtocolError("missing required 'reactionId'", { instance: message }); ++ return message; ++ }; ++ ++ /** ++ * Decodes a ReactComment message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof ReactComment ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {ReactComment} ReactComment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ReactComment.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a ReactComment message. ++ * @function verify ++ * @memberof ReactComment ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ ReactComment.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (!$util.isString(message.commentId)) ++ return "commentId: string expected"; ++ if (!$util.isInteger(message.reactionId)) ++ return "reactionId: integer expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a ReactComment message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof ReactComment ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {ReactComment} ReactComment ++ */ ++ ReactComment.fromObject = function fromObject(object) { ++ if (object instanceof $root.ReactComment) ++ return object; ++ var message = new $root.ReactComment(); ++ if (object.commentId != null) ++ message.commentId = String(object.commentId); ++ if (object.reactionId != null) ++ message.reactionId = object.reactionId >>> 0; ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a ReactComment message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof ReactComment ++ * @static ++ * @param {ReactComment} message ReactComment ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ ReactComment.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.commentId = ""; ++ object.reactionId = 0; ++ } ++ if (message.commentId != null && message.hasOwnProperty("commentId")) ++ object.commentId = message.commentId; ++ if (message.reactionId != null && message.hasOwnProperty("reactionId")) ++ object.reactionId = message.reactionId; ++ return object; ++ }; ++ ++ /** ++ * Converts this ReactComment to JSON. ++ * @function toJSON ++ * @memberof ReactComment ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ ReactComment.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return ReactComment; ++})(); ++ ++$root.CreateComment = (function() { ++ ++ /** ++ * Properties of a CreateComment. ++ * @exports ICreateComment ++ * @interface ICreateComment ++ * @property {Long} videoId CreateComment videoId ++ * @property {string|null} [parentCommentId] CreateComment parentCommentId ++ * @property {string} body CreateComment body ++ */ ++ ++ /** ++ * Constructs a new CreateComment. ++ * @exports CreateComment ++ * @classdesc Represents a CreateComment. ++ * @implements ICreateComment ++ * @constructor ++ * @param {ICreateComment=} [properties] Properties to set ++ */ ++ function CreateComment(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * CreateComment videoId. ++ * @member {Long} videoId ++ * @memberof CreateComment ++ * @instance ++ */ ++ CreateComment.prototype.videoId = $util.Long ? $util.Long.fromBits(0,0,true) : 0; ++ ++ /** ++ * CreateComment parentCommentId. ++ * @member {string} parentCommentId ++ * @memberof CreateComment ++ * @instance ++ */ ++ CreateComment.prototype.parentCommentId = ""; ++ ++ /** ++ * CreateComment body. ++ * @member {string} body ++ * @memberof CreateComment ++ * @instance ++ */ ++ CreateComment.prototype.body = ""; ++ ++ /** ++ * Creates a new CreateComment instance using the specified properties. ++ * @function create ++ * @memberof CreateComment ++ * @static ++ * @param {ICreateComment=} [properties] Properties to set ++ * @returns {CreateComment} CreateComment instance ++ */ ++ CreateComment.create = function create(properties) { ++ return new CreateComment(properties); ++ }; ++ ++ /** ++ * Encodes the specified CreateComment message. Does not implicitly {@link CreateComment.verify|verify} messages. ++ * @function encode ++ * @memberof CreateComment ++ * @static ++ * @param {ICreateComment} message CreateComment message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ CreateComment.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.videoId); ++ if (message.parentCommentId != null && Object.hasOwnProperty.call(message, "parentCommentId")) ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.parentCommentId); ++ writer.uint32(/* id 3, wireType 2 =*/26).string(message.body); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified CreateComment message, length delimited. Does not implicitly {@link CreateComment.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof CreateComment ++ * @static ++ * @param {ICreateComment} message CreateComment message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ CreateComment.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a CreateComment message from the specified reader or buffer. ++ * @function decode ++ * @memberof CreateComment ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {CreateComment} CreateComment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ CreateComment.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.CreateComment(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.videoId = reader.uint64(); ++ break; ++ case 2: ++ message.parentCommentId = reader.string(); ++ break; ++ case 3: ++ message.body = reader.string(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ if (!message.hasOwnProperty("videoId")) ++ throw $util.ProtocolError("missing required 'videoId'", { instance: message }); ++ if (!message.hasOwnProperty("body")) ++ throw $util.ProtocolError("missing required 'body'", { instance: message }); ++ return message; ++ }; ++ ++ /** ++ * Decodes a CreateComment message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof CreateComment ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {CreateComment} CreateComment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ CreateComment.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a CreateComment message. ++ * @function verify ++ * @memberof CreateComment ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ CreateComment.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (!$util.isInteger(message.videoId) && !(message.videoId && $util.isInteger(message.videoId.low) && $util.isInteger(message.videoId.high))) ++ return "videoId: integer|Long expected"; ++ if (message.parentCommentId != null && message.hasOwnProperty("parentCommentId")) ++ if (!$util.isString(message.parentCommentId)) ++ return "parentCommentId: string expected"; ++ if (!$util.isString(message.body)) ++ return "body: string expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a CreateComment message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof CreateComment ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {CreateComment} CreateComment ++ */ ++ CreateComment.fromObject = function fromObject(object) { ++ if (object instanceof $root.CreateComment) ++ return object; ++ var message = new $root.CreateComment(); ++ if (object.videoId != null) ++ if ($util.Long) ++ (message.videoId = $util.Long.fromValue(object.videoId)).unsigned = true; ++ else if (typeof object.videoId === "string") ++ message.videoId = parseInt(object.videoId, 10); ++ else if (typeof object.videoId === "number") ++ message.videoId = object.videoId; ++ else if (typeof object.videoId === "object") ++ message.videoId = new $util.LongBits(object.videoId.low >>> 0, object.videoId.high >>> 0).toNumber(true); ++ if (object.parentCommentId != null) ++ message.parentCommentId = String(object.parentCommentId); ++ if (object.body != null) ++ message.body = String(object.body); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a CreateComment message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof CreateComment ++ * @static ++ * @param {CreateComment} message CreateComment ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ CreateComment.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ if ($util.Long) { ++ var long = new $util.Long(0, 0, true); ++ object.videoId = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; ++ } else ++ object.videoId = options.longs === String ? "0" : 0; ++ object.parentCommentId = ""; ++ object.body = ""; ++ } ++ if (message.videoId != null && message.hasOwnProperty("videoId")) ++ if (typeof message.videoId === "number") ++ object.videoId = options.longs === String ? String(message.videoId) : message.videoId; ++ else ++ object.videoId = options.longs === String ? $util.Long.prototype.toString.call(message.videoId) : options.longs === Number ? new $util.LongBits(message.videoId.low >>> 0, message.videoId.high >>> 0).toNumber(true) : message.videoId; ++ if (message.parentCommentId != null && message.hasOwnProperty("parentCommentId")) ++ object.parentCommentId = message.parentCommentId; ++ if (message.body != null && message.hasOwnProperty("body")) ++ object.body = message.body; ++ return object; ++ }; ++ ++ /** ++ * Converts this CreateComment to JSON. ++ * @function toJSON ++ * @memberof CreateComment ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ CreateComment.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return CreateComment; ++})(); ++ ++$root.EditComment = (function() { ++ ++ /** ++ * Properties of an EditComment. ++ * @exports IEditComment ++ * @interface IEditComment ++ * @property {string} commentId EditComment commentId ++ * @property {string} newBody EditComment newBody ++ */ ++ ++ /** ++ * Constructs a new EditComment. ++ * @exports EditComment ++ * @classdesc Represents an EditComment. ++ * @implements IEditComment ++ * @constructor ++ * @param {IEditComment=} [properties] Properties to set ++ */ ++ function EditComment(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * EditComment commentId. ++ * @member {string} commentId ++ * @memberof EditComment ++ * @instance ++ */ ++ EditComment.prototype.commentId = ""; ++ ++ /** ++ * EditComment newBody. ++ * @member {string} newBody ++ * @memberof EditComment ++ * @instance ++ */ ++ EditComment.prototype.newBody = ""; ++ ++ /** ++ * Creates a new EditComment instance using the specified properties. ++ * @function create ++ * @memberof EditComment ++ * @static ++ * @param {IEditComment=} [properties] Properties to set ++ * @returns {EditComment} EditComment instance ++ */ ++ EditComment.create = function create(properties) { ++ return new EditComment(properties); ++ }; ++ ++ /** ++ * Encodes the specified EditComment message. Does not implicitly {@link EditComment.verify|verify} messages. ++ * @function encode ++ * @memberof EditComment ++ * @static ++ * @param {IEditComment} message EditComment message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ EditComment.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.commentId); ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.newBody); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified EditComment message, length delimited. Does not implicitly {@link EditComment.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof EditComment ++ * @static ++ * @param {IEditComment} message EditComment message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ EditComment.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes an EditComment message from the specified reader or buffer. ++ * @function decode ++ * @memberof EditComment ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {EditComment} EditComment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ EditComment.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.EditComment(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.commentId = reader.string(); ++ break; ++ case 2: ++ message.newBody = reader.string(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ if (!message.hasOwnProperty("commentId")) ++ throw $util.ProtocolError("missing required 'commentId'", { instance: message }); ++ if (!message.hasOwnProperty("newBody")) ++ throw $util.ProtocolError("missing required 'newBody'", { instance: message }); ++ return message; ++ }; ++ ++ /** ++ * Decodes an EditComment message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof EditComment ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {EditComment} EditComment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ EditComment.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies an EditComment message. ++ * @function verify ++ * @memberof EditComment ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ EditComment.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (!$util.isString(message.commentId)) ++ return "commentId: string expected"; ++ if (!$util.isString(message.newBody)) ++ return "newBody: string expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates an EditComment message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof EditComment ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {EditComment} EditComment ++ */ ++ EditComment.fromObject = function fromObject(object) { ++ if (object instanceof $root.EditComment) ++ return object; ++ var message = new $root.EditComment(); ++ if (object.commentId != null) ++ message.commentId = String(object.commentId); ++ if (object.newBody != null) ++ message.newBody = String(object.newBody); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from an EditComment message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof EditComment ++ * @static ++ * @param {EditComment} message EditComment ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ EditComment.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.commentId = ""; ++ object.newBody = ""; ++ } ++ if (message.commentId != null && message.hasOwnProperty("commentId")) ++ object.commentId = message.commentId; ++ if (message.newBody != null && message.hasOwnProperty("newBody")) ++ object.newBody = message.newBody; ++ return object; ++ }; ++ ++ /** ++ * Converts this EditComment to JSON. ++ * @function toJSON ++ * @memberof EditComment ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ EditComment.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return EditComment; ++})(); ++ ++$root.DeleteComment = (function() { ++ ++ /** ++ * Properties of a DeleteComment. ++ * @exports IDeleteComment ++ * @interface IDeleteComment ++ * @property {string} commentId DeleteComment commentId ++ */ ++ ++ /** ++ * Constructs a new DeleteComment. ++ * @exports DeleteComment ++ * @classdesc Represents a DeleteComment. ++ * @implements IDeleteComment ++ * @constructor ++ * @param {IDeleteComment=} [properties] Properties to set ++ */ ++ function DeleteComment(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * DeleteComment commentId. ++ * @member {string} commentId ++ * @memberof DeleteComment ++ * @instance ++ */ ++ DeleteComment.prototype.commentId = ""; ++ ++ /** ++ * Creates a new DeleteComment instance using the specified properties. ++ * @function create ++ * @memberof DeleteComment ++ * @static ++ * @param {IDeleteComment=} [properties] Properties to set ++ * @returns {DeleteComment} DeleteComment instance ++ */ ++ DeleteComment.create = function create(properties) { ++ return new DeleteComment(properties); ++ }; ++ ++ /** ++ * Encodes the specified DeleteComment message. Does not implicitly {@link DeleteComment.verify|verify} messages. ++ * @function encode ++ * @memberof DeleteComment ++ * @static ++ * @param {IDeleteComment} message DeleteComment message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ DeleteComment.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.commentId); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified DeleteComment message, length delimited. Does not implicitly {@link DeleteComment.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof DeleteComment ++ * @static ++ * @param {IDeleteComment} message DeleteComment message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ DeleteComment.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a DeleteComment message from the specified reader or buffer. ++ * @function decode ++ * @memberof DeleteComment ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {DeleteComment} DeleteComment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ DeleteComment.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.DeleteComment(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.commentId = reader.string(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ if (!message.hasOwnProperty("commentId")) ++ throw $util.ProtocolError("missing required 'commentId'", { instance: message }); ++ return message; ++ }; ++ ++ /** ++ * Decodes a DeleteComment message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof DeleteComment ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {DeleteComment} DeleteComment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ DeleteComment.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a DeleteComment message. ++ * @function verify ++ * @memberof DeleteComment ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ DeleteComment.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (!$util.isString(message.commentId)) ++ return "commentId: string expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a DeleteComment message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof DeleteComment ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {DeleteComment} DeleteComment ++ */ ++ DeleteComment.fromObject = function fromObject(object) { ++ if (object instanceof $root.DeleteComment) ++ return object; ++ var message = new $root.DeleteComment(); ++ if (object.commentId != null) ++ message.commentId = String(object.commentId); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a DeleteComment message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof DeleteComment ++ * @static ++ * @param {DeleteComment} message DeleteComment ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ DeleteComment.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) ++ object.commentId = ""; ++ if (message.commentId != null && message.hasOwnProperty("commentId")) ++ object.commentId = message.commentId; ++ return object; ++ }; ++ ++ /** ++ * Converts this DeleteComment to JSON. ++ * @function toJSON ++ * @memberof DeleteComment ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ DeleteComment.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return DeleteComment; ++})(); ++ ++$root.PinOrUnpinComment = (function() { ++ ++ /** ++ * Properties of a PinOrUnpinComment. ++ * @exports IPinOrUnpinComment ++ * @interface IPinOrUnpinComment ++ * @property {Long} videoId PinOrUnpinComment videoId ++ * @property {string} commentId PinOrUnpinComment commentId ++ * @property {PinOrUnpinComment.Option} option PinOrUnpinComment option ++ */ ++ ++ /** ++ * Constructs a new PinOrUnpinComment. ++ * @exports PinOrUnpinComment ++ * @classdesc Represents a PinOrUnpinComment. ++ * @implements IPinOrUnpinComment ++ * @constructor ++ * @param {IPinOrUnpinComment=} [properties] Properties to set ++ */ ++ function PinOrUnpinComment(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * PinOrUnpinComment videoId. ++ * @member {Long} videoId ++ * @memberof PinOrUnpinComment ++ * @instance ++ */ ++ PinOrUnpinComment.prototype.videoId = $util.Long ? $util.Long.fromBits(0,0,true) : 0; ++ ++ /** ++ * PinOrUnpinComment commentId. ++ * @member {string} commentId ++ * @memberof PinOrUnpinComment ++ * @instance ++ */ ++ PinOrUnpinComment.prototype.commentId = ""; ++ ++ /** ++ * PinOrUnpinComment option. ++ * @member {PinOrUnpinComment.Option} option ++ * @memberof PinOrUnpinComment ++ * @instance ++ */ ++ PinOrUnpinComment.prototype.option = 0; ++ ++ /** ++ * Creates a new PinOrUnpinComment instance using the specified properties. ++ * @function create ++ * @memberof PinOrUnpinComment ++ * @static ++ * @param {IPinOrUnpinComment=} [properties] Properties to set ++ * @returns {PinOrUnpinComment} PinOrUnpinComment instance ++ */ ++ PinOrUnpinComment.create = function create(properties) { ++ return new PinOrUnpinComment(properties); ++ }; ++ ++ /** ++ * Encodes the specified PinOrUnpinComment message. Does not implicitly {@link PinOrUnpinComment.verify|verify} messages. ++ * @function encode ++ * @memberof PinOrUnpinComment ++ * @static ++ * @param {IPinOrUnpinComment} message PinOrUnpinComment message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ PinOrUnpinComment.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.videoId); ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.commentId); ++ writer.uint32(/* id 3, wireType 0 =*/24).int32(message.option); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified PinOrUnpinComment message, length delimited. Does not implicitly {@link PinOrUnpinComment.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof PinOrUnpinComment ++ * @static ++ * @param {IPinOrUnpinComment} message PinOrUnpinComment message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ PinOrUnpinComment.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a PinOrUnpinComment message from the specified reader or buffer. ++ * @function decode ++ * @memberof PinOrUnpinComment ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {PinOrUnpinComment} PinOrUnpinComment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ PinOrUnpinComment.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.PinOrUnpinComment(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.videoId = reader.uint64(); ++ break; ++ case 2: ++ message.commentId = reader.string(); ++ break; ++ case 3: ++ message.option = reader.int32(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ if (!message.hasOwnProperty("videoId")) ++ throw $util.ProtocolError("missing required 'videoId'", { instance: message }); ++ if (!message.hasOwnProperty("commentId")) ++ throw $util.ProtocolError("missing required 'commentId'", { instance: message }); ++ if (!message.hasOwnProperty("option")) ++ throw $util.ProtocolError("missing required 'option'", { instance: message }); ++ return message; ++ }; ++ ++ /** ++ * Decodes a PinOrUnpinComment message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof PinOrUnpinComment ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {PinOrUnpinComment} PinOrUnpinComment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ PinOrUnpinComment.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a PinOrUnpinComment message. ++ * @function verify ++ * @memberof PinOrUnpinComment ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ PinOrUnpinComment.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (!$util.isInteger(message.videoId) && !(message.videoId && $util.isInteger(message.videoId.low) && $util.isInteger(message.videoId.high))) ++ return "videoId: integer|Long expected"; ++ if (!$util.isString(message.commentId)) ++ return "commentId: string expected"; ++ switch (message.option) { ++ default: ++ return "option: enum value expected"; ++ case 0: ++ case 1: ++ break; ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates a PinOrUnpinComment message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof PinOrUnpinComment ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {PinOrUnpinComment} PinOrUnpinComment ++ */ ++ PinOrUnpinComment.fromObject = function fromObject(object) { ++ if (object instanceof $root.PinOrUnpinComment) ++ return object; ++ var message = new $root.PinOrUnpinComment(); ++ if (object.videoId != null) ++ if ($util.Long) ++ (message.videoId = $util.Long.fromValue(object.videoId)).unsigned = true; ++ else if (typeof object.videoId === "string") ++ message.videoId = parseInt(object.videoId, 10); ++ else if (typeof object.videoId === "number") ++ message.videoId = object.videoId; ++ else if (typeof object.videoId === "object") ++ message.videoId = new $util.LongBits(object.videoId.low >>> 0, object.videoId.high >>> 0).toNumber(true); ++ if (object.commentId != null) ++ message.commentId = String(object.commentId); ++ switch (object.option) { ++ case "PIN": ++ case 0: ++ message.option = 0; ++ break; ++ case "UNPIN": ++ case 1: ++ message.option = 1; ++ break; ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a PinOrUnpinComment message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof PinOrUnpinComment ++ * @static ++ * @param {PinOrUnpinComment} message PinOrUnpinComment ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ PinOrUnpinComment.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ if ($util.Long) { ++ var long = new $util.Long(0, 0, true); ++ object.videoId = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; ++ } else ++ object.videoId = options.longs === String ? "0" : 0; ++ object.commentId = ""; ++ object.option = options.enums === String ? "PIN" : 0; ++ } ++ if (message.videoId != null && message.hasOwnProperty("videoId")) ++ if (typeof message.videoId === "number") ++ object.videoId = options.longs === String ? String(message.videoId) : message.videoId; ++ else ++ object.videoId = options.longs === String ? $util.Long.prototype.toString.call(message.videoId) : options.longs === Number ? new $util.LongBits(message.videoId.low >>> 0, message.videoId.high >>> 0).toNumber(true) : message.videoId; ++ if (message.commentId != null && message.hasOwnProperty("commentId")) ++ object.commentId = message.commentId; ++ if (message.option != null && message.hasOwnProperty("option")) ++ object.option = options.enums === String ? $root.PinOrUnpinComment.Option[message.option] : message.option; ++ return object; ++ }; ++ ++ /** ++ * Converts this PinOrUnpinComment to JSON. ++ * @function toJSON ++ * @memberof PinOrUnpinComment ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ PinOrUnpinComment.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ /** ++ * Option enum. ++ * @name PinOrUnpinComment.Option ++ * @enum {number} ++ * @property {number} PIN=0 PIN value ++ * @property {number} UNPIN=1 UNPIN value ++ */ ++ PinOrUnpinComment.Option = (function() { ++ var valuesById = {}, values = Object.create(valuesById); ++ values[valuesById[0] = "PIN"] = 0; ++ values[valuesById[1] = "UNPIN"] = 1; ++ return values; ++ })(); ++ ++ return PinOrUnpinComment; ++})(); ++ ++$root.ModerateComment = (function() { ++ ++ /** ++ * Properties of a ModerateComment. ++ * @exports IModerateComment ++ * @interface IModerateComment ++ * @property {string} commentId ModerateComment commentId ++ * @property {string} rationale ModerateComment rationale ++ */ ++ ++ /** ++ * Constructs a new ModerateComment. ++ * @exports ModerateComment ++ * @classdesc Represents a ModerateComment. ++ * @implements IModerateComment ++ * @constructor ++ * @param {IModerateComment=} [properties] Properties to set ++ */ ++ function ModerateComment(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * ModerateComment commentId. ++ * @member {string} commentId ++ * @memberof ModerateComment ++ * @instance ++ */ ++ ModerateComment.prototype.commentId = ""; ++ ++ /** ++ * ModerateComment rationale. ++ * @member {string} rationale ++ * @memberof ModerateComment ++ * @instance ++ */ ++ ModerateComment.prototype.rationale = ""; ++ ++ /** ++ * Creates a new ModerateComment instance using the specified properties. ++ * @function create ++ * @memberof ModerateComment ++ * @static ++ * @param {IModerateComment=} [properties] Properties to set ++ * @returns {ModerateComment} ModerateComment instance ++ */ ++ ModerateComment.create = function create(properties) { ++ return new ModerateComment(properties); ++ }; ++ ++ /** ++ * Encodes the specified ModerateComment message. Does not implicitly {@link ModerateComment.verify|verify} messages. ++ * @function encode ++ * @memberof ModerateComment ++ * @static ++ * @param {IModerateComment} message ModerateComment message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ModerateComment.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.commentId); ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.rationale); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified ModerateComment message, length delimited. Does not implicitly {@link ModerateComment.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof ModerateComment ++ * @static ++ * @param {IModerateComment} message ModerateComment message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ModerateComment.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a ModerateComment message from the specified reader or buffer. ++ * @function decode ++ * @memberof ModerateComment ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {ModerateComment} ModerateComment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ModerateComment.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ModerateComment(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.commentId = reader.string(); ++ break; ++ case 2: ++ message.rationale = reader.string(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ if (!message.hasOwnProperty("commentId")) ++ throw $util.ProtocolError("missing required 'commentId'", { instance: message }); ++ if (!message.hasOwnProperty("rationale")) ++ throw $util.ProtocolError("missing required 'rationale'", { instance: message }); ++ return message; ++ }; ++ ++ /** ++ * Decodes a ModerateComment message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof ModerateComment ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {ModerateComment} ModerateComment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ModerateComment.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a ModerateComment message. ++ * @function verify ++ * @memberof ModerateComment ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ ModerateComment.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (!$util.isString(message.commentId)) ++ return "commentId: string expected"; ++ if (!$util.isString(message.rationale)) ++ return "rationale: string expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a ModerateComment message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof ModerateComment ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {ModerateComment} ModerateComment ++ */ ++ ModerateComment.fromObject = function fromObject(object) { ++ if (object instanceof $root.ModerateComment) ++ return object; ++ var message = new $root.ModerateComment(); ++ if (object.commentId != null) ++ message.commentId = String(object.commentId); ++ if (object.rationale != null) ++ message.rationale = String(object.rationale); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a ModerateComment message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof ModerateComment ++ * @static ++ * @param {ModerateComment} message ModerateComment ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ ModerateComment.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.commentId = ""; ++ object.rationale = ""; ++ } ++ if (message.commentId != null && message.hasOwnProperty("commentId")) ++ object.commentId = message.commentId; ++ if (message.rationale != null && message.hasOwnProperty("rationale")) ++ object.rationale = message.rationale; ++ return object; ++ }; ++ ++ /** ++ * Converts this ModerateComment to JSON. ++ * @function toJSON ++ * @memberof ModerateComment ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ ModerateComment.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return ModerateComment; ++})(); ++ ++$root.BanOrUnbanMemberFromChannel = (function() { ++ ++ /** ++ * Properties of a BanOrUnbanMemberFromChannel. ++ * @exports IBanOrUnbanMemberFromChannel ++ * @interface IBanOrUnbanMemberFromChannel ++ * @property {Long} memberId BanOrUnbanMemberFromChannel memberId ++ * @property {BanOrUnbanMemberFromChannel.Option} option BanOrUnbanMemberFromChannel option ++ */ ++ ++ /** ++ * Constructs a new BanOrUnbanMemberFromChannel. ++ * @exports BanOrUnbanMemberFromChannel ++ * @classdesc Represents a BanOrUnbanMemberFromChannel. ++ * @implements IBanOrUnbanMemberFromChannel ++ * @constructor ++ * @param {IBanOrUnbanMemberFromChannel=} [properties] Properties to set ++ */ ++ function BanOrUnbanMemberFromChannel(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * BanOrUnbanMemberFromChannel memberId. ++ * @member {Long} memberId ++ * @memberof BanOrUnbanMemberFromChannel ++ * @instance ++ */ ++ BanOrUnbanMemberFromChannel.prototype.memberId = $util.Long ? $util.Long.fromBits(0,0,true) : 0; ++ ++ /** ++ * BanOrUnbanMemberFromChannel option. ++ * @member {BanOrUnbanMemberFromChannel.Option} option ++ * @memberof BanOrUnbanMemberFromChannel ++ * @instance ++ */ ++ BanOrUnbanMemberFromChannel.prototype.option = 0; ++ ++ /** ++ * Creates a new BanOrUnbanMemberFromChannel instance using the specified properties. ++ * @function create ++ * @memberof BanOrUnbanMemberFromChannel ++ * @static ++ * @param {IBanOrUnbanMemberFromChannel=} [properties] Properties to set ++ * @returns {BanOrUnbanMemberFromChannel} BanOrUnbanMemberFromChannel instance ++ */ ++ BanOrUnbanMemberFromChannel.create = function create(properties) { ++ return new BanOrUnbanMemberFromChannel(properties); ++ }; ++ ++ /** ++ * Encodes the specified BanOrUnbanMemberFromChannel message. Does not implicitly {@link BanOrUnbanMemberFromChannel.verify|verify} messages. ++ * @function encode ++ * @memberof BanOrUnbanMemberFromChannel ++ * @static ++ * @param {IBanOrUnbanMemberFromChannel} message BanOrUnbanMemberFromChannel message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ BanOrUnbanMemberFromChannel.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.memberId); ++ writer.uint32(/* id 2, wireType 0 =*/16).int32(message.option); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified BanOrUnbanMemberFromChannel message, length delimited. Does not implicitly {@link BanOrUnbanMemberFromChannel.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof BanOrUnbanMemberFromChannel ++ * @static ++ * @param {IBanOrUnbanMemberFromChannel} message BanOrUnbanMemberFromChannel message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ BanOrUnbanMemberFromChannel.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a BanOrUnbanMemberFromChannel message from the specified reader or buffer. ++ * @function decode ++ * @memberof BanOrUnbanMemberFromChannel ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {BanOrUnbanMemberFromChannel} BanOrUnbanMemberFromChannel ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ BanOrUnbanMemberFromChannel.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.BanOrUnbanMemberFromChannel(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.memberId = reader.uint64(); ++ break; ++ case 2: ++ message.option = reader.int32(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ if (!message.hasOwnProperty("memberId")) ++ throw $util.ProtocolError("missing required 'memberId'", { instance: message }); ++ if (!message.hasOwnProperty("option")) ++ throw $util.ProtocolError("missing required 'option'", { instance: message }); ++ return message; ++ }; ++ ++ /** ++ * Decodes a BanOrUnbanMemberFromChannel message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof BanOrUnbanMemberFromChannel ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {BanOrUnbanMemberFromChannel} BanOrUnbanMemberFromChannel ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ BanOrUnbanMemberFromChannel.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a BanOrUnbanMemberFromChannel message. ++ * @function verify ++ * @memberof BanOrUnbanMemberFromChannel ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ BanOrUnbanMemberFromChannel.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (!$util.isInteger(message.memberId) && !(message.memberId && $util.isInteger(message.memberId.low) && $util.isInteger(message.memberId.high))) ++ return "memberId: integer|Long expected"; ++ switch (message.option) { ++ default: ++ return "option: enum value expected"; ++ case 0: ++ case 1: ++ break; ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates a BanOrUnbanMemberFromChannel message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof BanOrUnbanMemberFromChannel ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {BanOrUnbanMemberFromChannel} BanOrUnbanMemberFromChannel ++ */ ++ BanOrUnbanMemberFromChannel.fromObject = function fromObject(object) { ++ if (object instanceof $root.BanOrUnbanMemberFromChannel) ++ return object; ++ var message = new $root.BanOrUnbanMemberFromChannel(); ++ if (object.memberId != null) ++ if ($util.Long) ++ (message.memberId = $util.Long.fromValue(object.memberId)).unsigned = true; ++ else if (typeof object.memberId === "string") ++ message.memberId = parseInt(object.memberId, 10); ++ else if (typeof object.memberId === "number") ++ message.memberId = object.memberId; ++ else if (typeof object.memberId === "object") ++ message.memberId = new $util.LongBits(object.memberId.low >>> 0, object.memberId.high >>> 0).toNumber(true); ++ switch (object.option) { ++ case "BAN": ++ case 0: ++ message.option = 0; ++ break; ++ case "UNBAN": ++ case 1: ++ message.option = 1; ++ break; ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a BanOrUnbanMemberFromChannel message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof BanOrUnbanMemberFromChannel ++ * @static ++ * @param {BanOrUnbanMemberFromChannel} message BanOrUnbanMemberFromChannel ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ BanOrUnbanMemberFromChannel.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ if ($util.Long) { ++ var long = new $util.Long(0, 0, true); ++ object.memberId = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; ++ } else ++ object.memberId = options.longs === String ? "0" : 0; ++ object.option = options.enums === String ? "BAN" : 0; ++ } ++ if (message.memberId != null && message.hasOwnProperty("memberId")) ++ if (typeof message.memberId === "number") ++ object.memberId = options.longs === String ? String(message.memberId) : message.memberId; ++ else ++ object.memberId = options.longs === String ? $util.Long.prototype.toString.call(message.memberId) : options.longs === Number ? new $util.LongBits(message.memberId.low >>> 0, message.memberId.high >>> 0).toNumber(true) : message.memberId; ++ if (message.option != null && message.hasOwnProperty("option")) ++ object.option = options.enums === String ? $root.BanOrUnbanMemberFromChannel.Option[message.option] : message.option; ++ return object; ++ }; ++ ++ /** ++ * Converts this BanOrUnbanMemberFromChannel to JSON. ++ * @function toJSON ++ * @memberof BanOrUnbanMemberFromChannel ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ BanOrUnbanMemberFromChannel.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ /** ++ * Option enum. ++ * @name BanOrUnbanMemberFromChannel.Option ++ * @enum {number} ++ * @property {number} BAN=0 BAN value ++ * @property {number} UNBAN=1 UNBAN value ++ */ ++ BanOrUnbanMemberFromChannel.Option = (function() { ++ var valuesById = {}, values = Object.create(valuesById); ++ values[valuesById[0] = "BAN"] = 0; ++ values[valuesById[1] = "UNBAN"] = 1; ++ return values; ++ })(); ++ ++ return BanOrUnbanMemberFromChannel; ++})(); ++ ++$root.VideoReactionsPreference = (function() { ++ ++ /** ++ * Properties of a VideoReactionsPreference. ++ * @exports IVideoReactionsPreference ++ * @interface IVideoReactionsPreference ++ * @property {Long} videoId VideoReactionsPreference videoId ++ * @property {VideoReactionsPreference.Option} option VideoReactionsPreference option ++ */ ++ ++ /** ++ * Constructs a new VideoReactionsPreference. ++ * @exports VideoReactionsPreference ++ * @classdesc Represents a VideoReactionsPreference. ++ * @implements IVideoReactionsPreference ++ * @constructor ++ * @param {IVideoReactionsPreference=} [properties] Properties to set ++ */ ++ function VideoReactionsPreference(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * VideoReactionsPreference videoId. ++ * @member {Long} videoId ++ * @memberof VideoReactionsPreference ++ * @instance ++ */ ++ VideoReactionsPreference.prototype.videoId = $util.Long ? $util.Long.fromBits(0,0,true) : 0; ++ ++ /** ++ * VideoReactionsPreference option. ++ * @member {VideoReactionsPreference.Option} option ++ * @memberof VideoReactionsPreference ++ * @instance ++ */ ++ VideoReactionsPreference.prototype.option = 0; ++ ++ /** ++ * Creates a new VideoReactionsPreference instance using the specified properties. ++ * @function create ++ * @memberof VideoReactionsPreference ++ * @static ++ * @param {IVideoReactionsPreference=} [properties] Properties to set ++ * @returns {VideoReactionsPreference} VideoReactionsPreference instance ++ */ ++ VideoReactionsPreference.create = function create(properties) { ++ return new VideoReactionsPreference(properties); ++ }; ++ ++ /** ++ * Encodes the specified VideoReactionsPreference message. Does not implicitly {@link VideoReactionsPreference.verify|verify} messages. ++ * @function encode ++ * @memberof VideoReactionsPreference ++ * @static ++ * @param {IVideoReactionsPreference} message VideoReactionsPreference message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ VideoReactionsPreference.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.videoId); ++ writer.uint32(/* id 2, wireType 0 =*/16).int32(message.option); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified VideoReactionsPreference message, length delimited. Does not implicitly {@link VideoReactionsPreference.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof VideoReactionsPreference ++ * @static ++ * @param {IVideoReactionsPreference} message VideoReactionsPreference message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ VideoReactionsPreference.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a VideoReactionsPreference message from the specified reader or buffer. ++ * @function decode ++ * @memberof VideoReactionsPreference ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {VideoReactionsPreference} VideoReactionsPreference ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ VideoReactionsPreference.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.VideoReactionsPreference(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.videoId = reader.uint64(); ++ break; ++ case 2: ++ message.option = reader.int32(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ if (!message.hasOwnProperty("videoId")) ++ throw $util.ProtocolError("missing required 'videoId'", { instance: message }); ++ if (!message.hasOwnProperty("option")) ++ throw $util.ProtocolError("missing required 'option'", { instance: message }); ++ return message; ++ }; ++ ++ /** ++ * Decodes a VideoReactionsPreference message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof VideoReactionsPreference ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {VideoReactionsPreference} VideoReactionsPreference ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ VideoReactionsPreference.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a VideoReactionsPreference message. ++ * @function verify ++ * @memberof VideoReactionsPreference ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ VideoReactionsPreference.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (!$util.isInteger(message.videoId) && !(message.videoId && $util.isInteger(message.videoId.low) && $util.isInteger(message.videoId.high))) ++ return "videoId: integer|Long expected"; ++ switch (message.option) { ++ default: ++ return "option: enum value expected"; ++ case 0: ++ case 1: ++ break; ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates a VideoReactionsPreference message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof VideoReactionsPreference ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {VideoReactionsPreference} VideoReactionsPreference ++ */ ++ VideoReactionsPreference.fromObject = function fromObject(object) { ++ if (object instanceof $root.VideoReactionsPreference) ++ return object; ++ var message = new $root.VideoReactionsPreference(); ++ if (object.videoId != null) ++ if ($util.Long) ++ (message.videoId = $util.Long.fromValue(object.videoId)).unsigned = true; ++ else if (typeof object.videoId === "string") ++ message.videoId = parseInt(object.videoId, 10); ++ else if (typeof object.videoId === "number") ++ message.videoId = object.videoId; ++ else if (typeof object.videoId === "object") ++ message.videoId = new $util.LongBits(object.videoId.low >>> 0, object.videoId.high >>> 0).toNumber(true); ++ switch (object.option) { ++ case "ENABLE": ++ case 0: ++ message.option = 0; ++ break; ++ case "DISABLE": ++ case 1: ++ message.option = 1; ++ break; ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a VideoReactionsPreference message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof VideoReactionsPreference ++ * @static ++ * @param {VideoReactionsPreference} message VideoReactionsPreference ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ VideoReactionsPreference.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ if ($util.Long) { ++ var long = new $util.Long(0, 0, true); ++ object.videoId = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; ++ } else ++ object.videoId = options.longs === String ? "0" : 0; ++ object.option = options.enums === String ? "ENABLE" : 0; ++ } ++ if (message.videoId != null && message.hasOwnProperty("videoId")) ++ if (typeof message.videoId === "number") ++ object.videoId = options.longs === String ? String(message.videoId) : message.videoId; ++ else ++ object.videoId = options.longs === String ? $util.Long.prototype.toString.call(message.videoId) : options.longs === Number ? new $util.LongBits(message.videoId.low >>> 0, message.videoId.high >>> 0).toNumber(true) : message.videoId; ++ if (message.option != null && message.hasOwnProperty("option")) ++ object.option = options.enums === String ? $root.VideoReactionsPreference.Option[message.option] : message.option; ++ return object; ++ }; ++ ++ /** ++ * Converts this VideoReactionsPreference to JSON. ++ * @function toJSON ++ * @memberof VideoReactionsPreference ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ VideoReactionsPreference.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ /** ++ * Option enum. ++ * @name VideoReactionsPreference.Option ++ * @enum {number} ++ * @property {number} ENABLE=0 ENABLE value ++ * @property {number} DISABLE=1 DISABLE value ++ */ ++ VideoReactionsPreference.Option = (function() { ++ var valuesById = {}, values = Object.create(valuesById); ++ values[valuesById[0] = "ENABLE"] = 0; ++ values[valuesById[1] = "DISABLE"] = 1; ++ return values; ++ })(); ++ ++ return VideoReactionsPreference; ++})(); ++ ++$root.CreateVideoCategory = (function() { ++ ++ /** ++ * Properties of a CreateVideoCategory. ++ * @exports ICreateVideoCategory ++ * @interface ICreateVideoCategory ++ * @property {string} name CreateVideoCategory name ++ * @property {string|null} [description] CreateVideoCategory description ++ * @property {string|null} [parentCategoryId] CreateVideoCategory parentCategoryId ++ */ ++ ++ /** ++ * Constructs a new CreateVideoCategory. ++ * @exports CreateVideoCategory ++ * @classdesc Represents a CreateVideoCategory. ++ * @implements ICreateVideoCategory ++ * @constructor ++ * @param {ICreateVideoCategory=} [properties] Properties to set ++ */ ++ function CreateVideoCategory(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * CreateVideoCategory name. ++ * @member {string} name ++ * @memberof CreateVideoCategory ++ * @instance ++ */ ++ CreateVideoCategory.prototype.name = ""; ++ ++ /** ++ * CreateVideoCategory description. ++ * @member {string} description ++ * @memberof CreateVideoCategory ++ * @instance ++ */ ++ CreateVideoCategory.prototype.description = ""; ++ ++ /** ++ * CreateVideoCategory parentCategoryId. ++ * @member {string} parentCategoryId ++ * @memberof CreateVideoCategory ++ * @instance ++ */ ++ CreateVideoCategory.prototype.parentCategoryId = ""; ++ ++ /** ++ * Creates a new CreateVideoCategory instance using the specified properties. ++ * @function create ++ * @memberof CreateVideoCategory ++ * @static ++ * @param {ICreateVideoCategory=} [properties] Properties to set ++ * @returns {CreateVideoCategory} CreateVideoCategory instance ++ */ ++ CreateVideoCategory.create = function create(properties) { ++ return new CreateVideoCategory(properties); ++ }; ++ ++ /** ++ * Encodes the specified CreateVideoCategory message. Does not implicitly {@link CreateVideoCategory.verify|verify} messages. ++ * @function encode ++ * @memberof CreateVideoCategory ++ * @static ++ * @param {ICreateVideoCategory} message CreateVideoCategory message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ CreateVideoCategory.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.name); ++ if (message.description != null && Object.hasOwnProperty.call(message, "description")) ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.description); ++ if (message.parentCategoryId != null && Object.hasOwnProperty.call(message, "parentCategoryId")) ++ writer.uint32(/* id 3, wireType 2 =*/26).string(message.parentCategoryId); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified CreateVideoCategory message, length delimited. Does not implicitly {@link CreateVideoCategory.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof CreateVideoCategory ++ * @static ++ * @param {ICreateVideoCategory} message CreateVideoCategory message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ CreateVideoCategory.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a CreateVideoCategory message from the specified reader or buffer. ++ * @function decode ++ * @memberof CreateVideoCategory ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {CreateVideoCategory} CreateVideoCategory ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ CreateVideoCategory.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.CreateVideoCategory(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.name = reader.string(); ++ break; ++ case 2: ++ message.description = reader.string(); ++ break; ++ case 3: ++ message.parentCategoryId = reader.string(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ if (!message.hasOwnProperty("name")) ++ throw $util.ProtocolError("missing required 'name'", { instance: message }); ++ return message; ++ }; ++ ++ /** ++ * Decodes a CreateVideoCategory message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof CreateVideoCategory ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {CreateVideoCategory} CreateVideoCategory ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ CreateVideoCategory.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a CreateVideoCategory message. ++ * @function verify ++ * @memberof CreateVideoCategory ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ CreateVideoCategory.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (!$util.isString(message.name)) ++ return "name: string expected"; ++ if (message.description != null && message.hasOwnProperty("description")) ++ if (!$util.isString(message.description)) ++ return "description: string expected"; ++ if (message.parentCategoryId != null && message.hasOwnProperty("parentCategoryId")) ++ if (!$util.isString(message.parentCategoryId)) ++ return "parentCategoryId: string expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a CreateVideoCategory message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof CreateVideoCategory ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {CreateVideoCategory} CreateVideoCategory ++ */ ++ CreateVideoCategory.fromObject = function fromObject(object) { ++ if (object instanceof $root.CreateVideoCategory) ++ return object; ++ var message = new $root.CreateVideoCategory(); ++ if (object.name != null) ++ message.name = String(object.name); ++ if (object.description != null) ++ message.description = String(object.description); ++ if (object.parentCategoryId != null) ++ message.parentCategoryId = String(object.parentCategoryId); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a CreateVideoCategory message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof CreateVideoCategory ++ * @static ++ * @param {CreateVideoCategory} message CreateVideoCategory ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ CreateVideoCategory.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.name = ""; ++ object.description = ""; ++ object.parentCategoryId = ""; ++ } ++ if (message.name != null && message.hasOwnProperty("name")) ++ object.name = message.name; ++ if (message.description != null && message.hasOwnProperty("description")) ++ object.description = message.description; ++ if (message.parentCategoryId != null && message.hasOwnProperty("parentCategoryId")) ++ object.parentCategoryId = message.parentCategoryId; ++ return object; ++ }; ++ ++ /** ++ * Converts this CreateVideoCategory to JSON. ++ * @function toJSON ++ * @memberof CreateVideoCategory ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ CreateVideoCategory.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return CreateVideoCategory; ++})(); ++ ++$root.MakeChannelPayment = (function() { ++ ++ /** ++ * Properties of a MakeChannelPayment. ++ * @exports IMakeChannelPayment ++ * @interface IMakeChannelPayment ++ * @property {string|null} [rationale] MakeChannelPayment rationale ++ * @property {Long|null} [videoId] MakeChannelPayment videoId ++ */ ++ ++ /** ++ * Constructs a new MakeChannelPayment. ++ * @exports MakeChannelPayment ++ * @classdesc Represents a MakeChannelPayment. ++ * @implements IMakeChannelPayment ++ * @constructor ++ * @param {IMakeChannelPayment=} [properties] Properties to set ++ */ ++ function MakeChannelPayment(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * MakeChannelPayment rationale. ++ * @member {string} rationale ++ * @memberof MakeChannelPayment ++ * @instance ++ */ ++ MakeChannelPayment.prototype.rationale = ""; ++ ++ /** ++ * MakeChannelPayment videoId. ++ * @member {Long|null|undefined} videoId ++ * @memberof MakeChannelPayment ++ * @instance ++ */ ++ MakeChannelPayment.prototype.videoId = null; ++ ++ // OneOf field names bound to virtual getters and setters ++ var $oneOfFields; ++ ++ /** ++ * MakeChannelPayment paymentContext. ++ * @member {"videoId"|undefined} paymentContext ++ * @memberof MakeChannelPayment ++ * @instance ++ */ ++ Object.defineProperty(MakeChannelPayment.prototype, "paymentContext", { ++ get: $util.oneOfGetter($oneOfFields = ["videoId"]), ++ set: $util.oneOfSetter($oneOfFields) ++ }); ++ ++ /** ++ * Creates a new MakeChannelPayment instance using the specified properties. ++ * @function create ++ * @memberof MakeChannelPayment ++ * @static ++ * @param {IMakeChannelPayment=} [properties] Properties to set ++ * @returns {MakeChannelPayment} MakeChannelPayment instance ++ */ ++ MakeChannelPayment.create = function create(properties) { ++ return new MakeChannelPayment(properties); ++ }; ++ ++ /** ++ * Encodes the specified MakeChannelPayment message. Does not implicitly {@link MakeChannelPayment.verify|verify} messages. ++ * @function encode ++ * @memberof MakeChannelPayment ++ * @static ++ * @param {IMakeChannelPayment} message MakeChannelPayment message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ MakeChannelPayment.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.rationale != null && Object.hasOwnProperty.call(message, "rationale")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.rationale); ++ if (message.videoId != null && Object.hasOwnProperty.call(message, "videoId")) ++ writer.uint32(/* id 2, wireType 0 =*/16).uint64(message.videoId); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified MakeChannelPayment message, length delimited. Does not implicitly {@link MakeChannelPayment.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof MakeChannelPayment ++ * @static ++ * @param {IMakeChannelPayment} message MakeChannelPayment message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ MakeChannelPayment.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a MakeChannelPayment message from the specified reader or buffer. ++ * @function decode ++ * @memberof MakeChannelPayment ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {MakeChannelPayment} MakeChannelPayment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ MakeChannelPayment.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.MakeChannelPayment(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.rationale = reader.string(); ++ break; ++ case 2: ++ message.videoId = reader.uint64(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a MakeChannelPayment message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof MakeChannelPayment ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {MakeChannelPayment} MakeChannelPayment ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ MakeChannelPayment.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a MakeChannelPayment message. ++ * @function verify ++ * @memberof MakeChannelPayment ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ MakeChannelPayment.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ var properties = {}; ++ if (message.rationale != null && message.hasOwnProperty("rationale")) ++ if (!$util.isString(message.rationale)) ++ return "rationale: string expected"; ++ if (message.videoId != null && message.hasOwnProperty("videoId")) { ++ properties.paymentContext = 1; ++ if (!$util.isInteger(message.videoId) && !(message.videoId && $util.isInteger(message.videoId.low) && $util.isInteger(message.videoId.high))) ++ return "videoId: integer|Long expected"; ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates a MakeChannelPayment message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof MakeChannelPayment ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {MakeChannelPayment} MakeChannelPayment ++ */ ++ MakeChannelPayment.fromObject = function fromObject(object) { ++ if (object instanceof $root.MakeChannelPayment) ++ return object; ++ var message = new $root.MakeChannelPayment(); ++ if (object.rationale != null) ++ message.rationale = String(object.rationale); ++ if (object.videoId != null) ++ if ($util.Long) ++ (message.videoId = $util.Long.fromValue(object.videoId)).unsigned = true; ++ else if (typeof object.videoId === "string") ++ message.videoId = parseInt(object.videoId, 10); ++ else if (typeof object.videoId === "number") ++ message.videoId = object.videoId; ++ else if (typeof object.videoId === "object") ++ message.videoId = new $util.LongBits(object.videoId.low >>> 0, object.videoId.high >>> 0).toNumber(true); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a MakeChannelPayment message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof MakeChannelPayment ++ * @static ++ * @param {MakeChannelPayment} message MakeChannelPayment ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ MakeChannelPayment.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) ++ object.rationale = ""; ++ if (message.rationale != null && message.hasOwnProperty("rationale")) ++ object.rationale = message.rationale; ++ if (message.videoId != null && message.hasOwnProperty("videoId")) { ++ if (typeof message.videoId === "number") ++ object.videoId = options.longs === String ? String(message.videoId) : message.videoId; ++ else ++ object.videoId = options.longs === String ? $util.Long.prototype.toString.call(message.videoId) : options.longs === Number ? new $util.LongBits(message.videoId.low >>> 0, message.videoId.high >>> 0).toNumber(true) : message.videoId; ++ if (options.oneofs) ++ object.paymentContext = "videoId"; ++ } ++ return object; ++ }; ++ ++ /** ++ * Converts this MakeChannelPayment to JSON. ++ * @function toJSON ++ * @memberof MakeChannelPayment ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ MakeChannelPayment.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return MakeChannelPayment; ++})(); ++ ++$root.AppMetadata = (function() { ++ ++ /** ++ * Properties of an AppMetadata. ++ * @exports IAppMetadata ++ * @interface IAppMetadata ++ * @property {string|null} [websiteUrl] AppMetadata websiteUrl ++ * @property {string|null} [useUri] AppMetadata useUri ++ * @property {string|null} [smallIcon] AppMetadata smallIcon ++ * @property {string|null} [mediumIcon] AppMetadata mediumIcon ++ * @property {string|null} [bigIcon] AppMetadata bigIcon ++ * @property {string|null} [oneLiner] AppMetadata oneLiner ++ * @property {string|null} [description] AppMetadata description ++ * @property {string|null} [termsOfService] AppMetadata termsOfService ++ * @property {string|null} [authKey] AppMetadata authKey ++ * @property {Array.|null} [platforms] AppMetadata platforms ++ * @property {string|null} [category] AppMetadata category ++ */ ++ ++ /** ++ * Constructs a new AppMetadata. ++ * @exports AppMetadata ++ * @classdesc Represents an AppMetadata. ++ * @implements IAppMetadata ++ * @constructor ++ * @param {IAppMetadata=} [properties] Properties to set ++ */ ++ function AppMetadata(properties) { ++ this.platforms = []; ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * AppMetadata websiteUrl. ++ * @member {string} websiteUrl ++ * @memberof AppMetadata ++ * @instance ++ */ ++ AppMetadata.prototype.websiteUrl = ""; ++ ++ /** ++ * AppMetadata useUri. ++ * @member {string} useUri ++ * @memberof AppMetadata ++ * @instance ++ */ ++ AppMetadata.prototype.useUri = ""; ++ ++ /** ++ * AppMetadata smallIcon. ++ * @member {string} smallIcon ++ * @memberof AppMetadata ++ * @instance ++ */ ++ AppMetadata.prototype.smallIcon = ""; ++ ++ /** ++ * AppMetadata mediumIcon. ++ * @member {string} mediumIcon ++ * @memberof AppMetadata ++ * @instance ++ */ ++ AppMetadata.prototype.mediumIcon = ""; ++ ++ /** ++ * AppMetadata bigIcon. ++ * @member {string} bigIcon ++ * @memberof AppMetadata ++ * @instance ++ */ ++ AppMetadata.prototype.bigIcon = ""; ++ ++ /** ++ * AppMetadata oneLiner. ++ * @member {string} oneLiner ++ * @memberof AppMetadata ++ * @instance ++ */ ++ AppMetadata.prototype.oneLiner = ""; ++ ++ /** ++ * AppMetadata description. ++ * @member {string} description ++ * @memberof AppMetadata ++ * @instance ++ */ ++ AppMetadata.prototype.description = ""; ++ ++ /** ++ * AppMetadata termsOfService. ++ * @member {string} termsOfService ++ * @memberof AppMetadata ++ * @instance ++ */ ++ AppMetadata.prototype.termsOfService = ""; ++ ++ /** ++ * AppMetadata authKey. ++ * @member {string} authKey ++ * @memberof AppMetadata ++ * @instance ++ */ ++ AppMetadata.prototype.authKey = ""; ++ ++ /** ++ * AppMetadata platforms. ++ * @member {Array.} platforms ++ * @memberof AppMetadata ++ * @instance ++ */ ++ AppMetadata.prototype.platforms = $util.emptyArray; ++ ++ /** ++ * AppMetadata category. ++ * @member {string} category ++ * @memberof AppMetadata ++ * @instance ++ */ ++ AppMetadata.prototype.category = ""; ++ ++ /** ++ * Creates a new AppMetadata instance using the specified properties. ++ * @function create ++ * @memberof AppMetadata ++ * @static ++ * @param {IAppMetadata=} [properties] Properties to set ++ * @returns {AppMetadata} AppMetadata instance ++ */ ++ AppMetadata.create = function create(properties) { ++ return new AppMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified AppMetadata message. Does not implicitly {@link AppMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof AppMetadata ++ * @static ++ * @param {IAppMetadata} message AppMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ AppMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.websiteUrl != null && Object.hasOwnProperty.call(message, "websiteUrl")) ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.websiteUrl); ++ if (message.useUri != null && Object.hasOwnProperty.call(message, "useUri")) ++ writer.uint32(/* id 3, wireType 2 =*/26).string(message.useUri); ++ if (message.smallIcon != null && Object.hasOwnProperty.call(message, "smallIcon")) ++ writer.uint32(/* id 4, wireType 2 =*/34).string(message.smallIcon); ++ if (message.mediumIcon != null && Object.hasOwnProperty.call(message, "mediumIcon")) ++ writer.uint32(/* id 5, wireType 2 =*/42).string(message.mediumIcon); ++ if (message.bigIcon != null && Object.hasOwnProperty.call(message, "bigIcon")) ++ writer.uint32(/* id 6, wireType 2 =*/50).string(message.bigIcon); ++ if (message.oneLiner != null && Object.hasOwnProperty.call(message, "oneLiner")) ++ writer.uint32(/* id 7, wireType 2 =*/58).string(message.oneLiner); ++ if (message.description != null && Object.hasOwnProperty.call(message, "description")) ++ writer.uint32(/* id 8, wireType 2 =*/66).string(message.description); ++ if (message.termsOfService != null && Object.hasOwnProperty.call(message, "termsOfService")) ++ writer.uint32(/* id 9, wireType 2 =*/74).string(message.termsOfService); ++ if (message.authKey != null && Object.hasOwnProperty.call(message, "authKey")) ++ writer.uint32(/* id 10, wireType 2 =*/82).string(message.authKey); ++ if (message.platforms != null && message.platforms.length) ++ for (var i = 0; i < message.platforms.length; ++i) ++ writer.uint32(/* id 11, wireType 2 =*/90).string(message.platforms[i]); ++ if (message.category != null && Object.hasOwnProperty.call(message, "category")) ++ writer.uint32(/* id 12, wireType 2 =*/98).string(message.category); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified AppMetadata message, length delimited. Does not implicitly {@link AppMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof AppMetadata ++ * @static ++ * @param {IAppMetadata} message AppMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ AppMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes an AppMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof AppMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {AppMetadata} AppMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ AppMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.AppMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 2: ++ message.websiteUrl = reader.string(); ++ break; ++ case 3: ++ message.useUri = reader.string(); ++ break; ++ case 4: ++ message.smallIcon = reader.string(); ++ break; ++ case 5: ++ message.mediumIcon = reader.string(); ++ break; ++ case 6: ++ message.bigIcon = reader.string(); ++ break; ++ case 7: ++ message.oneLiner = reader.string(); ++ break; ++ case 8: ++ message.description = reader.string(); ++ break; ++ case 9: ++ message.termsOfService = reader.string(); ++ break; ++ case 10: ++ message.authKey = reader.string(); ++ break; ++ case 11: ++ if (!(message.platforms && message.platforms.length)) ++ message.platforms = []; ++ message.platforms.push(reader.string()); ++ break; ++ case 12: ++ message.category = reader.string(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes an AppMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof AppMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {AppMetadata} AppMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ AppMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies an AppMetadata message. ++ * @function verify ++ * @memberof AppMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ AppMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.websiteUrl != null && message.hasOwnProperty("websiteUrl")) ++ if (!$util.isString(message.websiteUrl)) ++ return "websiteUrl: string expected"; ++ if (message.useUri != null && message.hasOwnProperty("useUri")) ++ if (!$util.isString(message.useUri)) ++ return "useUri: string expected"; ++ if (message.smallIcon != null && message.hasOwnProperty("smallIcon")) ++ if (!$util.isString(message.smallIcon)) ++ return "smallIcon: string expected"; ++ if (message.mediumIcon != null && message.hasOwnProperty("mediumIcon")) ++ if (!$util.isString(message.mediumIcon)) ++ return "mediumIcon: string expected"; ++ if (message.bigIcon != null && message.hasOwnProperty("bigIcon")) ++ if (!$util.isString(message.bigIcon)) ++ return "bigIcon: string expected"; ++ if (message.oneLiner != null && message.hasOwnProperty("oneLiner")) ++ if (!$util.isString(message.oneLiner)) ++ return "oneLiner: string expected"; ++ if (message.description != null && message.hasOwnProperty("description")) ++ if (!$util.isString(message.description)) ++ return "description: string expected"; ++ if (message.termsOfService != null && message.hasOwnProperty("termsOfService")) ++ if (!$util.isString(message.termsOfService)) ++ return "termsOfService: string expected"; ++ if (message.authKey != null && message.hasOwnProperty("authKey")) ++ if (!$util.isString(message.authKey)) ++ return "authKey: string expected"; ++ if (message.platforms != null && message.hasOwnProperty("platforms")) { ++ if (!Array.isArray(message.platforms)) ++ return "platforms: array expected"; ++ for (var i = 0; i < message.platforms.length; ++i) ++ if (!$util.isString(message.platforms[i])) ++ return "platforms: string[] expected"; ++ } ++ if (message.category != null && message.hasOwnProperty("category")) ++ if (!$util.isString(message.category)) ++ return "category: string expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates an AppMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof AppMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {AppMetadata} AppMetadata ++ */ ++ AppMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.AppMetadata) ++ return object; ++ var message = new $root.AppMetadata(); ++ if (object.websiteUrl != null) ++ message.websiteUrl = String(object.websiteUrl); ++ if (object.useUri != null) ++ message.useUri = String(object.useUri); ++ if (object.smallIcon != null) ++ message.smallIcon = String(object.smallIcon); ++ if (object.mediumIcon != null) ++ message.mediumIcon = String(object.mediumIcon); ++ if (object.bigIcon != null) ++ message.bigIcon = String(object.bigIcon); ++ if (object.oneLiner != null) ++ message.oneLiner = String(object.oneLiner); ++ if (object.description != null) ++ message.description = String(object.description); ++ if (object.termsOfService != null) ++ message.termsOfService = String(object.termsOfService); ++ if (object.authKey != null) ++ message.authKey = String(object.authKey); ++ if (object.platforms) { ++ if (!Array.isArray(object.platforms)) ++ throw TypeError(".AppMetadata.platforms: array expected"); ++ message.platforms = []; ++ for (var i = 0; i < object.platforms.length; ++i) ++ message.platforms[i] = String(object.platforms[i]); ++ } ++ if (object.category != null) ++ message.category = String(object.category); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from an AppMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof AppMetadata ++ * @static ++ * @param {AppMetadata} message AppMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ AppMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.arrays || options.defaults) ++ object.platforms = []; ++ if (options.defaults) { ++ object.websiteUrl = ""; ++ object.useUri = ""; ++ object.smallIcon = ""; ++ object.mediumIcon = ""; ++ object.bigIcon = ""; ++ object.oneLiner = ""; ++ object.description = ""; ++ object.termsOfService = ""; ++ object.authKey = ""; ++ object.category = ""; ++ } ++ if (message.websiteUrl != null && message.hasOwnProperty("websiteUrl")) ++ object.websiteUrl = message.websiteUrl; ++ if (message.useUri != null && message.hasOwnProperty("useUri")) ++ object.useUri = message.useUri; ++ if (message.smallIcon != null && message.hasOwnProperty("smallIcon")) ++ object.smallIcon = message.smallIcon; ++ if (message.mediumIcon != null && message.hasOwnProperty("mediumIcon")) ++ object.mediumIcon = message.mediumIcon; ++ if (message.bigIcon != null && message.hasOwnProperty("bigIcon")) ++ object.bigIcon = message.bigIcon; ++ if (message.oneLiner != null && message.hasOwnProperty("oneLiner")) ++ object.oneLiner = message.oneLiner; ++ if (message.description != null && message.hasOwnProperty("description")) ++ object.description = message.description; ++ if (message.termsOfService != null && message.hasOwnProperty("termsOfService")) ++ object.termsOfService = message.termsOfService; ++ if (message.authKey != null && message.hasOwnProperty("authKey")) ++ object.authKey = message.authKey; ++ if (message.platforms && message.platforms.length) { ++ object.platforms = []; ++ for (var j = 0; j < message.platforms.length; ++j) ++ object.platforms[j] = message.platforms[j]; ++ } ++ if (message.category != null && message.hasOwnProperty("category")) ++ object.category = message.category; ++ return object; ++ }; ++ ++ /** ++ * Converts this AppMetadata to JSON. ++ * @function toJSON ++ * @memberof AppMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ AppMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return AppMetadata; ++})(); ++ ++$root.CreateApp = (function() { ++ ++ /** ++ * Properties of a CreateApp. ++ * @exports ICreateApp ++ * @interface ICreateApp ++ * @property {string} name CreateApp name ++ * @property {IAppMetadata|null} [appMetadata] CreateApp appMetadata ++ */ ++ ++ /** ++ * Constructs a new CreateApp. ++ * @exports CreateApp ++ * @classdesc Represents a CreateApp. ++ * @implements ICreateApp ++ * @constructor ++ * @param {ICreateApp=} [properties] Properties to set ++ */ ++ function CreateApp(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * CreateApp name. ++ * @member {string} name ++ * @memberof CreateApp ++ * @instance ++ */ ++ CreateApp.prototype.name = ""; ++ ++ /** ++ * CreateApp appMetadata. ++ * @member {IAppMetadata|null|undefined} appMetadata ++ * @memberof CreateApp ++ * @instance ++ */ ++ CreateApp.prototype.appMetadata = null; ++ ++ /** ++ * Creates a new CreateApp instance using the specified properties. ++ * @function create ++ * @memberof CreateApp ++ * @static ++ * @param {ICreateApp=} [properties] Properties to set ++ * @returns {CreateApp} CreateApp instance ++ */ ++ CreateApp.create = function create(properties) { ++ return new CreateApp(properties); ++ }; ++ ++ /** ++ * Encodes the specified CreateApp message. Does not implicitly {@link CreateApp.verify|verify} messages. ++ * @function encode ++ * @memberof CreateApp ++ * @static ++ * @param {ICreateApp} message CreateApp message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ CreateApp.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.name); ++ if (message.appMetadata != null && Object.hasOwnProperty.call(message, "appMetadata")) ++ $root.AppMetadata.encode(message.appMetadata, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified CreateApp message, length delimited. Does not implicitly {@link CreateApp.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof CreateApp ++ * @static ++ * @param {ICreateApp} message CreateApp message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ CreateApp.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a CreateApp message from the specified reader or buffer. ++ * @function decode ++ * @memberof CreateApp ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {CreateApp} CreateApp ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ CreateApp.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.CreateApp(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.name = reader.string(); ++ break; ++ case 2: ++ message.appMetadata = $root.AppMetadata.decode(reader, reader.uint32()); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ if (!message.hasOwnProperty("name")) ++ throw $util.ProtocolError("missing required 'name'", { instance: message }); ++ return message; ++ }; ++ ++ /** ++ * Decodes a CreateApp message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof CreateApp ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {CreateApp} CreateApp ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ CreateApp.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a CreateApp message. ++ * @function verify ++ * @memberof CreateApp ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ CreateApp.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (!$util.isString(message.name)) ++ return "name: string expected"; ++ if (message.appMetadata != null && message.hasOwnProperty("appMetadata")) { ++ var error = $root.AppMetadata.verify(message.appMetadata); ++ if (error) ++ return "appMetadata." + error; ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates a CreateApp message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof CreateApp ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {CreateApp} CreateApp ++ */ ++ CreateApp.fromObject = function fromObject(object) { ++ if (object instanceof $root.CreateApp) ++ return object; ++ var message = new $root.CreateApp(); ++ if (object.name != null) ++ message.name = String(object.name); ++ if (object.appMetadata != null) { ++ if (typeof object.appMetadata !== "object") ++ throw TypeError(".CreateApp.appMetadata: object expected"); ++ message.appMetadata = $root.AppMetadata.fromObject(object.appMetadata); ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a CreateApp message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof CreateApp ++ * @static ++ * @param {CreateApp} message CreateApp ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ CreateApp.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.name = ""; ++ object.appMetadata = null; ++ } ++ if (message.name != null && message.hasOwnProperty("name")) ++ object.name = message.name; ++ if (message.appMetadata != null && message.hasOwnProperty("appMetadata")) ++ object.appMetadata = $root.AppMetadata.toObject(message.appMetadata, options); ++ return object; ++ }; ++ ++ /** ++ * Converts this CreateApp to JSON. ++ * @function toJSON ++ * @memberof CreateApp ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ CreateApp.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return CreateApp; ++})(); ++ ++$root.UpdateApp = (function() { ++ ++ /** ++ * Properties of an UpdateApp. ++ * @exports IUpdateApp ++ * @interface IUpdateApp ++ * @property {string} appId UpdateApp appId ++ * @property {IAppMetadata|null} [appMetadata] UpdateApp appMetadata ++ */ ++ ++ /** ++ * Constructs a new UpdateApp. ++ * @exports UpdateApp ++ * @classdesc Represents an UpdateApp. ++ * @implements IUpdateApp ++ * @constructor ++ * @param {IUpdateApp=} [properties] Properties to set ++ */ ++ function UpdateApp(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * UpdateApp appId. ++ * @member {string} appId ++ * @memberof UpdateApp ++ * @instance ++ */ ++ UpdateApp.prototype.appId = ""; ++ ++ /** ++ * UpdateApp appMetadata. ++ * @member {IAppMetadata|null|undefined} appMetadata ++ * @memberof UpdateApp ++ * @instance ++ */ ++ UpdateApp.prototype.appMetadata = null; ++ ++ /** ++ * Creates a new UpdateApp instance using the specified properties. ++ * @function create ++ * @memberof UpdateApp ++ * @static ++ * @param {IUpdateApp=} [properties] Properties to set ++ * @returns {UpdateApp} UpdateApp instance ++ */ ++ UpdateApp.create = function create(properties) { ++ return new UpdateApp(properties); ++ }; ++ ++ /** ++ * Encodes the specified UpdateApp message. Does not implicitly {@link UpdateApp.verify|verify} messages. ++ * @function encode ++ * @memberof UpdateApp ++ * @static ++ * @param {IUpdateApp} message UpdateApp message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ UpdateApp.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.appId); ++ if (message.appMetadata != null && Object.hasOwnProperty.call(message, "appMetadata")) ++ $root.AppMetadata.encode(message.appMetadata, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified UpdateApp message, length delimited. Does not implicitly {@link UpdateApp.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof UpdateApp ++ * @static ++ * @param {IUpdateApp} message UpdateApp message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ UpdateApp.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes an UpdateApp message from the specified reader or buffer. ++ * @function decode ++ * @memberof UpdateApp ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {UpdateApp} UpdateApp ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ UpdateApp.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.UpdateApp(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.appId = reader.string(); ++ break; ++ case 2: ++ message.appMetadata = $root.AppMetadata.decode(reader, reader.uint32()); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ if (!message.hasOwnProperty("appId")) ++ throw $util.ProtocolError("missing required 'appId'", { instance: message }); ++ return message; ++ }; ++ ++ /** ++ * Decodes an UpdateApp message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof UpdateApp ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {UpdateApp} UpdateApp ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ UpdateApp.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies an UpdateApp message. ++ * @function verify ++ * @memberof UpdateApp ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ UpdateApp.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (!$util.isString(message.appId)) ++ return "appId: string expected"; ++ if (message.appMetadata != null && message.hasOwnProperty("appMetadata")) { ++ var error = $root.AppMetadata.verify(message.appMetadata); ++ if (error) ++ return "appMetadata." + error; ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates an UpdateApp message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof UpdateApp ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {UpdateApp} UpdateApp ++ */ ++ UpdateApp.fromObject = function fromObject(object) { ++ if (object instanceof $root.UpdateApp) ++ return object; ++ var message = new $root.UpdateApp(); ++ if (object.appId != null) ++ message.appId = String(object.appId); ++ if (object.appMetadata != null) { ++ if (typeof object.appMetadata !== "object") ++ throw TypeError(".UpdateApp.appMetadata: object expected"); ++ message.appMetadata = $root.AppMetadata.fromObject(object.appMetadata); ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from an UpdateApp message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof UpdateApp ++ * @static ++ * @param {UpdateApp} message UpdateApp ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ UpdateApp.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.appId = ""; ++ object.appMetadata = null; ++ } ++ if (message.appId != null && message.hasOwnProperty("appId")) ++ object.appId = message.appId; ++ if (message.appMetadata != null && message.hasOwnProperty("appMetadata")) ++ object.appMetadata = $root.AppMetadata.toObject(message.appMetadata, options); ++ return object; ++ }; ++ ++ /** ++ * Converts this UpdateApp to JSON. ++ * @function toJSON ++ * @memberof UpdateApp ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ UpdateApp.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return UpdateApp; ++})(); ++ ++$root.MemberRemarked = (function() { ++ ++ /** ++ * Properties of a MemberRemarked. ++ * @exports IMemberRemarked ++ * @interface IMemberRemarked ++ * @property {IReactVideo|null} [reactVideo] MemberRemarked reactVideo ++ * @property {IReactComment|null} [reactComment] MemberRemarked reactComment ++ * @property {ICreateComment|null} [createComment] MemberRemarked createComment ++ * @property {IEditComment|null} [editComment] MemberRemarked editComment ++ * @property {IDeleteComment|null} [deleteComment] MemberRemarked deleteComment ++ * @property {ICreateVideoCategory|null} [createVideoCategory] MemberRemarked createVideoCategory ++ * @property {ICreateApp|null} [createApp] MemberRemarked createApp ++ * @property {IUpdateApp|null} [updateApp] MemberRemarked updateApp ++ * @property {IMakeChannelPayment|null} [makeChannelPayment] MemberRemarked makeChannelPayment ++ */ ++ ++ /** ++ * Constructs a new MemberRemarked. ++ * @exports MemberRemarked ++ * @classdesc Represents a MemberRemarked. ++ * @implements IMemberRemarked ++ * @constructor ++ * @param {IMemberRemarked=} [properties] Properties to set ++ */ ++ function MemberRemarked(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * MemberRemarked reactVideo. ++ * @member {IReactVideo|null|undefined} reactVideo ++ * @memberof MemberRemarked ++ * @instance ++ */ ++ MemberRemarked.prototype.reactVideo = null; ++ ++ /** ++ * MemberRemarked reactComment. ++ * @member {IReactComment|null|undefined} reactComment ++ * @memberof MemberRemarked ++ * @instance ++ */ ++ MemberRemarked.prototype.reactComment = null; ++ ++ /** ++ * MemberRemarked createComment. ++ * @member {ICreateComment|null|undefined} createComment ++ * @memberof MemberRemarked ++ * @instance ++ */ ++ MemberRemarked.prototype.createComment = null; ++ ++ /** ++ * MemberRemarked editComment. ++ * @member {IEditComment|null|undefined} editComment ++ * @memberof MemberRemarked ++ * @instance ++ */ ++ MemberRemarked.prototype.editComment = null; ++ ++ /** ++ * MemberRemarked deleteComment. ++ * @member {IDeleteComment|null|undefined} deleteComment ++ * @memberof MemberRemarked ++ * @instance ++ */ ++ MemberRemarked.prototype.deleteComment = null; ++ ++ /** ++ * MemberRemarked createVideoCategory. ++ * @member {ICreateVideoCategory|null|undefined} createVideoCategory ++ * @memberof MemberRemarked ++ * @instance ++ */ ++ MemberRemarked.prototype.createVideoCategory = null; ++ ++ /** ++ * MemberRemarked createApp. ++ * @member {ICreateApp|null|undefined} createApp ++ * @memberof MemberRemarked ++ * @instance ++ */ ++ MemberRemarked.prototype.createApp = null; ++ ++ /** ++ * MemberRemarked updateApp. ++ * @member {IUpdateApp|null|undefined} updateApp ++ * @memberof MemberRemarked ++ * @instance ++ */ ++ MemberRemarked.prototype.updateApp = null; ++ ++ /** ++ * MemberRemarked makeChannelPayment. ++ * @member {IMakeChannelPayment|null|undefined} makeChannelPayment ++ * @memberof MemberRemarked ++ * @instance ++ */ ++ MemberRemarked.prototype.makeChannelPayment = null; ++ ++ // OneOf field names bound to virtual getters and setters ++ var $oneOfFields; ++ ++ /** ++ * MemberRemarked memberRemarked. ++ * @member {"reactVideo"|"reactComment"|"createComment"|"editComment"|"deleteComment"|"createVideoCategory"|"createApp"|"updateApp"|"makeChannelPayment"|undefined} memberRemarked ++ * @memberof MemberRemarked ++ * @instance ++ */ ++ Object.defineProperty(MemberRemarked.prototype, "memberRemarked", { ++ get: $util.oneOfGetter($oneOfFields = ["reactVideo", "reactComment", "createComment", "editComment", "deleteComment", "createVideoCategory", "createApp", "updateApp", "makeChannelPayment"]), ++ set: $util.oneOfSetter($oneOfFields) ++ }); ++ ++ /** ++ * Creates a new MemberRemarked instance using the specified properties. ++ * @function create ++ * @memberof MemberRemarked ++ * @static ++ * @param {IMemberRemarked=} [properties] Properties to set ++ * @returns {MemberRemarked} MemberRemarked instance ++ */ ++ MemberRemarked.create = function create(properties) { ++ return new MemberRemarked(properties); ++ }; ++ ++ /** ++ * Encodes the specified MemberRemarked message. Does not implicitly {@link MemberRemarked.verify|verify} messages. ++ * @function encode ++ * @memberof MemberRemarked ++ * @static ++ * @param {IMemberRemarked} message MemberRemarked message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ MemberRemarked.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.reactVideo != null && Object.hasOwnProperty.call(message, "reactVideo")) ++ $root.ReactVideo.encode(message.reactVideo, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); ++ if (message.reactComment != null && Object.hasOwnProperty.call(message, "reactComment")) ++ $root.ReactComment.encode(message.reactComment, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); ++ if (message.createComment != null && Object.hasOwnProperty.call(message, "createComment")) ++ $root.CreateComment.encode(message.createComment, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim(); ++ if (message.editComment != null && Object.hasOwnProperty.call(message, "editComment")) ++ $root.EditComment.encode(message.editComment, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim(); ++ if (message.deleteComment != null && Object.hasOwnProperty.call(message, "deleteComment")) ++ $root.DeleteComment.encode(message.deleteComment, writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim(); ++ if (message.createVideoCategory != null && Object.hasOwnProperty.call(message, "createVideoCategory")) ++ $root.CreateVideoCategory.encode(message.createVideoCategory, writer.uint32(/* id 6, wireType 2 =*/50).fork()).ldelim(); ++ if (message.createApp != null && Object.hasOwnProperty.call(message, "createApp")) ++ $root.CreateApp.encode(message.createApp, writer.uint32(/* id 7, wireType 2 =*/58).fork()).ldelim(); ++ if (message.updateApp != null && Object.hasOwnProperty.call(message, "updateApp")) ++ $root.UpdateApp.encode(message.updateApp, writer.uint32(/* id 8, wireType 2 =*/66).fork()).ldelim(); ++ if (message.makeChannelPayment != null && Object.hasOwnProperty.call(message, "makeChannelPayment")) ++ $root.MakeChannelPayment.encode(message.makeChannelPayment, writer.uint32(/* id 10, wireType 2 =*/82).fork()).ldelim(); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified MemberRemarked message, length delimited. Does not implicitly {@link MemberRemarked.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof MemberRemarked ++ * @static ++ * @param {IMemberRemarked} message MemberRemarked message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ MemberRemarked.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a MemberRemarked message from the specified reader or buffer. ++ * @function decode ++ * @memberof MemberRemarked ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {MemberRemarked} MemberRemarked ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ MemberRemarked.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.MemberRemarked(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.reactVideo = $root.ReactVideo.decode(reader, reader.uint32()); ++ break; ++ case 2: ++ message.reactComment = $root.ReactComment.decode(reader, reader.uint32()); ++ break; ++ case 3: ++ message.createComment = $root.CreateComment.decode(reader, reader.uint32()); ++ break; ++ case 4: ++ message.editComment = $root.EditComment.decode(reader, reader.uint32()); ++ break; ++ case 5: ++ message.deleteComment = $root.DeleteComment.decode(reader, reader.uint32()); ++ break; ++ case 6: ++ message.createVideoCategory = $root.CreateVideoCategory.decode(reader, reader.uint32()); ++ break; ++ case 7: ++ message.createApp = $root.CreateApp.decode(reader, reader.uint32()); ++ break; ++ case 8: ++ message.updateApp = $root.UpdateApp.decode(reader, reader.uint32()); ++ break; ++ case 10: ++ message.makeChannelPayment = $root.MakeChannelPayment.decode(reader, reader.uint32()); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a MemberRemarked message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof MemberRemarked ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {MemberRemarked} MemberRemarked ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ MemberRemarked.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a MemberRemarked message. ++ * @function verify ++ * @memberof MemberRemarked ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ MemberRemarked.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ var properties = {}; ++ if (message.reactVideo != null && message.hasOwnProperty("reactVideo")) { ++ properties.memberRemarked = 1; ++ { ++ var error = $root.ReactVideo.verify(message.reactVideo); ++ if (error) ++ return "reactVideo." + error; ++ } ++ } ++ if (message.reactComment != null && message.hasOwnProperty("reactComment")) { ++ if (properties.memberRemarked === 1) ++ return "memberRemarked: multiple values"; ++ properties.memberRemarked = 1; ++ { ++ var error = $root.ReactComment.verify(message.reactComment); ++ if (error) ++ return "reactComment." + error; ++ } ++ } ++ if (message.createComment != null && message.hasOwnProperty("createComment")) { ++ if (properties.memberRemarked === 1) ++ return "memberRemarked: multiple values"; ++ properties.memberRemarked = 1; ++ { ++ var error = $root.CreateComment.verify(message.createComment); ++ if (error) ++ return "createComment." + error; ++ } ++ } ++ if (message.editComment != null && message.hasOwnProperty("editComment")) { ++ if (properties.memberRemarked === 1) ++ return "memberRemarked: multiple values"; ++ properties.memberRemarked = 1; ++ { ++ var error = $root.EditComment.verify(message.editComment); ++ if (error) ++ return "editComment." + error; ++ } ++ } ++ if (message.deleteComment != null && message.hasOwnProperty("deleteComment")) { ++ if (properties.memberRemarked === 1) ++ return "memberRemarked: multiple values"; ++ properties.memberRemarked = 1; ++ { ++ var error = $root.DeleteComment.verify(message.deleteComment); ++ if (error) ++ return "deleteComment." + error; ++ } ++ } ++ if (message.createVideoCategory != null && message.hasOwnProperty("createVideoCategory")) { ++ if (properties.memberRemarked === 1) ++ return "memberRemarked: multiple values"; ++ properties.memberRemarked = 1; ++ { ++ var error = $root.CreateVideoCategory.verify(message.createVideoCategory); ++ if (error) ++ return "createVideoCategory." + error; ++ } ++ } ++ if (message.createApp != null && message.hasOwnProperty("createApp")) { ++ if (properties.memberRemarked === 1) ++ return "memberRemarked: multiple values"; ++ properties.memberRemarked = 1; ++ { ++ var error = $root.CreateApp.verify(message.createApp); ++ if (error) ++ return "createApp." + error; ++ } ++ } ++ if (message.updateApp != null && message.hasOwnProperty("updateApp")) { ++ if (properties.memberRemarked === 1) ++ return "memberRemarked: multiple values"; ++ properties.memberRemarked = 1; ++ { ++ var error = $root.UpdateApp.verify(message.updateApp); ++ if (error) ++ return "updateApp." + error; ++ } ++ } ++ if (message.makeChannelPayment != null && message.hasOwnProperty("makeChannelPayment")) { ++ if (properties.memberRemarked === 1) ++ return "memberRemarked: multiple values"; ++ properties.memberRemarked = 1; ++ { ++ var error = $root.MakeChannelPayment.verify(message.makeChannelPayment); ++ if (error) ++ return "makeChannelPayment." + error; ++ } ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates a MemberRemarked message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof MemberRemarked ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {MemberRemarked} MemberRemarked ++ */ ++ MemberRemarked.fromObject = function fromObject(object) { ++ if (object instanceof $root.MemberRemarked) ++ return object; ++ var message = new $root.MemberRemarked(); ++ if (object.reactVideo != null) { ++ if (typeof object.reactVideo !== "object") ++ throw TypeError(".MemberRemarked.reactVideo: object expected"); ++ message.reactVideo = $root.ReactVideo.fromObject(object.reactVideo); ++ } ++ if (object.reactComment != null) { ++ if (typeof object.reactComment !== "object") ++ throw TypeError(".MemberRemarked.reactComment: object expected"); ++ message.reactComment = $root.ReactComment.fromObject(object.reactComment); ++ } ++ if (object.createComment != null) { ++ if (typeof object.createComment !== "object") ++ throw TypeError(".MemberRemarked.createComment: object expected"); ++ message.createComment = $root.CreateComment.fromObject(object.createComment); ++ } ++ if (object.editComment != null) { ++ if (typeof object.editComment !== "object") ++ throw TypeError(".MemberRemarked.editComment: object expected"); ++ message.editComment = $root.EditComment.fromObject(object.editComment); ++ } ++ if (object.deleteComment != null) { ++ if (typeof object.deleteComment !== "object") ++ throw TypeError(".MemberRemarked.deleteComment: object expected"); ++ message.deleteComment = $root.DeleteComment.fromObject(object.deleteComment); ++ } ++ if (object.createVideoCategory != null) { ++ if (typeof object.createVideoCategory !== "object") ++ throw TypeError(".MemberRemarked.createVideoCategory: object expected"); ++ message.createVideoCategory = $root.CreateVideoCategory.fromObject(object.createVideoCategory); ++ } ++ if (object.createApp != null) { ++ if (typeof object.createApp !== "object") ++ throw TypeError(".MemberRemarked.createApp: object expected"); ++ message.createApp = $root.CreateApp.fromObject(object.createApp); ++ } ++ if (object.updateApp != null) { ++ if (typeof object.updateApp !== "object") ++ throw TypeError(".MemberRemarked.updateApp: object expected"); ++ message.updateApp = $root.UpdateApp.fromObject(object.updateApp); ++ } ++ if (object.makeChannelPayment != null) { ++ if (typeof object.makeChannelPayment !== "object") ++ throw TypeError(".MemberRemarked.makeChannelPayment: object expected"); ++ message.makeChannelPayment = $root.MakeChannelPayment.fromObject(object.makeChannelPayment); ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a MemberRemarked message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof MemberRemarked ++ * @static ++ * @param {MemberRemarked} message MemberRemarked ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ MemberRemarked.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (message.reactVideo != null && message.hasOwnProperty("reactVideo")) { ++ object.reactVideo = $root.ReactVideo.toObject(message.reactVideo, options); ++ if (options.oneofs) ++ object.memberRemarked = "reactVideo"; ++ } ++ if (message.reactComment != null && message.hasOwnProperty("reactComment")) { ++ object.reactComment = $root.ReactComment.toObject(message.reactComment, options); ++ if (options.oneofs) ++ object.memberRemarked = "reactComment"; ++ } ++ if (message.createComment != null && message.hasOwnProperty("createComment")) { ++ object.createComment = $root.CreateComment.toObject(message.createComment, options); ++ if (options.oneofs) ++ object.memberRemarked = "createComment"; ++ } ++ if (message.editComment != null && message.hasOwnProperty("editComment")) { ++ object.editComment = $root.EditComment.toObject(message.editComment, options); ++ if (options.oneofs) ++ object.memberRemarked = "editComment"; ++ } ++ if (message.deleteComment != null && message.hasOwnProperty("deleteComment")) { ++ object.deleteComment = $root.DeleteComment.toObject(message.deleteComment, options); ++ if (options.oneofs) ++ object.memberRemarked = "deleteComment"; ++ } ++ if (message.createVideoCategory != null && message.hasOwnProperty("createVideoCategory")) { ++ object.createVideoCategory = $root.CreateVideoCategory.toObject(message.createVideoCategory, options); ++ if (options.oneofs) ++ object.memberRemarked = "createVideoCategory"; ++ } ++ if (message.createApp != null && message.hasOwnProperty("createApp")) { ++ object.createApp = $root.CreateApp.toObject(message.createApp, options); ++ if (options.oneofs) ++ object.memberRemarked = "createApp"; ++ } ++ if (message.updateApp != null && message.hasOwnProperty("updateApp")) { ++ object.updateApp = $root.UpdateApp.toObject(message.updateApp, options); ++ if (options.oneofs) ++ object.memberRemarked = "updateApp"; ++ } ++ if (message.makeChannelPayment != null && message.hasOwnProperty("makeChannelPayment")) { ++ object.makeChannelPayment = $root.MakeChannelPayment.toObject(message.makeChannelPayment, options); ++ if (options.oneofs) ++ object.memberRemarked = "makeChannelPayment"; ++ } ++ return object; ++ }; ++ ++ /** ++ * Converts this MemberRemarked to JSON. ++ * @function toJSON ++ * @memberof MemberRemarked ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ MemberRemarked.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return MemberRemarked; ++})(); ++ ++$root.ChannelModeratorRemarked = (function() { ++ ++ /** ++ * Properties of a ChannelModeratorRemarked. ++ * @exports IChannelModeratorRemarked ++ * @interface IChannelModeratorRemarked ++ * @property {IModerateComment|null} [moderateComment] ChannelModeratorRemarked moderateComment ++ */ ++ ++ /** ++ * Constructs a new ChannelModeratorRemarked. ++ * @exports ChannelModeratorRemarked ++ * @classdesc Represents a ChannelModeratorRemarked. ++ * @implements IChannelModeratorRemarked ++ * @constructor ++ * @param {IChannelModeratorRemarked=} [properties] Properties to set ++ */ ++ function ChannelModeratorRemarked(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * ChannelModeratorRemarked moderateComment. ++ * @member {IModerateComment|null|undefined} moderateComment ++ * @memberof ChannelModeratorRemarked ++ * @instance ++ */ ++ ChannelModeratorRemarked.prototype.moderateComment = null; ++ ++ // OneOf field names bound to virtual getters and setters ++ var $oneOfFields; ++ ++ /** ++ * ChannelModeratorRemarked channelModeratorRemarked. ++ * @member {"moderateComment"|undefined} channelModeratorRemarked ++ * @memberof ChannelModeratorRemarked ++ * @instance ++ */ ++ Object.defineProperty(ChannelModeratorRemarked.prototype, "channelModeratorRemarked", { ++ get: $util.oneOfGetter($oneOfFields = ["moderateComment"]), ++ set: $util.oneOfSetter($oneOfFields) ++ }); ++ ++ /** ++ * Creates a new ChannelModeratorRemarked instance using the specified properties. ++ * @function create ++ * @memberof ChannelModeratorRemarked ++ * @static ++ * @param {IChannelModeratorRemarked=} [properties] Properties to set ++ * @returns {ChannelModeratorRemarked} ChannelModeratorRemarked instance ++ */ ++ ChannelModeratorRemarked.create = function create(properties) { ++ return new ChannelModeratorRemarked(properties); ++ }; ++ ++ /** ++ * Encodes the specified ChannelModeratorRemarked message. Does not implicitly {@link ChannelModeratorRemarked.verify|verify} messages. ++ * @function encode ++ * @memberof ChannelModeratorRemarked ++ * @static ++ * @param {IChannelModeratorRemarked} message ChannelModeratorRemarked message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ChannelModeratorRemarked.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.moderateComment != null && Object.hasOwnProperty.call(message, "moderateComment")) ++ $root.ModerateComment.encode(message.moderateComment, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified ChannelModeratorRemarked message, length delimited. Does not implicitly {@link ChannelModeratorRemarked.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof ChannelModeratorRemarked ++ * @static ++ * @param {IChannelModeratorRemarked} message ChannelModeratorRemarked message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ChannelModeratorRemarked.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a ChannelModeratorRemarked message from the specified reader or buffer. ++ * @function decode ++ * @memberof ChannelModeratorRemarked ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {ChannelModeratorRemarked} ChannelModeratorRemarked ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ChannelModeratorRemarked.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ChannelModeratorRemarked(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.moderateComment = $root.ModerateComment.decode(reader, reader.uint32()); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a ChannelModeratorRemarked message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof ChannelModeratorRemarked ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {ChannelModeratorRemarked} ChannelModeratorRemarked ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ChannelModeratorRemarked.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a ChannelModeratorRemarked message. ++ * @function verify ++ * @memberof ChannelModeratorRemarked ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ ChannelModeratorRemarked.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ var properties = {}; ++ if (message.moderateComment != null && message.hasOwnProperty("moderateComment")) { ++ properties.channelModeratorRemarked = 1; ++ { ++ var error = $root.ModerateComment.verify(message.moderateComment); ++ if (error) ++ return "moderateComment." + error; ++ } ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates a ChannelModeratorRemarked message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof ChannelModeratorRemarked ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {ChannelModeratorRemarked} ChannelModeratorRemarked ++ */ ++ ChannelModeratorRemarked.fromObject = function fromObject(object) { ++ if (object instanceof $root.ChannelModeratorRemarked) ++ return object; ++ var message = new $root.ChannelModeratorRemarked(); ++ if (object.moderateComment != null) { ++ if (typeof object.moderateComment !== "object") ++ throw TypeError(".ChannelModeratorRemarked.moderateComment: object expected"); ++ message.moderateComment = $root.ModerateComment.fromObject(object.moderateComment); ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a ChannelModeratorRemarked message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof ChannelModeratorRemarked ++ * @static ++ * @param {ChannelModeratorRemarked} message ChannelModeratorRemarked ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ ChannelModeratorRemarked.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (message.moderateComment != null && message.hasOwnProperty("moderateComment")) { ++ object.moderateComment = $root.ModerateComment.toObject(message.moderateComment, options); ++ if (options.oneofs) ++ object.channelModeratorRemarked = "moderateComment"; ++ } ++ return object; ++ }; ++ ++ /** ++ * Converts this ChannelModeratorRemarked to JSON. ++ * @function toJSON ++ * @memberof ChannelModeratorRemarked ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ ChannelModeratorRemarked.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return ChannelModeratorRemarked; ++})(); ++ ++$root.ChannelOwnerRemarked = (function() { ++ ++ /** ++ * Properties of a ChannelOwnerRemarked. ++ * @exports IChannelOwnerRemarked ++ * @interface IChannelOwnerRemarked ++ * @property {IPinOrUnpinComment|null} [pinOrUnpinComment] ChannelOwnerRemarked pinOrUnpinComment ++ * @property {IBanOrUnbanMemberFromChannel|null} [banOrUnbanMemberFromChannel] ChannelOwnerRemarked banOrUnbanMemberFromChannel ++ * @property {IVideoReactionsPreference|null} [videoReactionsPreference] ChannelOwnerRemarked videoReactionsPreference ++ * @property {IModerateComment|null} [moderateComment] ChannelOwnerRemarked moderateComment ++ */ ++ ++ /** ++ * Constructs a new ChannelOwnerRemarked. ++ * @exports ChannelOwnerRemarked ++ * @classdesc Represents a ChannelOwnerRemarked. ++ * @implements IChannelOwnerRemarked ++ * @constructor ++ * @param {IChannelOwnerRemarked=} [properties] Properties to set ++ */ ++ function ChannelOwnerRemarked(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * ChannelOwnerRemarked pinOrUnpinComment. ++ * @member {IPinOrUnpinComment|null|undefined} pinOrUnpinComment ++ * @memberof ChannelOwnerRemarked ++ * @instance ++ */ ++ ChannelOwnerRemarked.prototype.pinOrUnpinComment = null; ++ ++ /** ++ * ChannelOwnerRemarked banOrUnbanMemberFromChannel. ++ * @member {IBanOrUnbanMemberFromChannel|null|undefined} banOrUnbanMemberFromChannel ++ * @memberof ChannelOwnerRemarked ++ * @instance ++ */ ++ ChannelOwnerRemarked.prototype.banOrUnbanMemberFromChannel = null; ++ ++ /** ++ * ChannelOwnerRemarked videoReactionsPreference. ++ * @member {IVideoReactionsPreference|null|undefined} videoReactionsPreference ++ * @memberof ChannelOwnerRemarked ++ * @instance ++ */ ++ ChannelOwnerRemarked.prototype.videoReactionsPreference = null; ++ ++ /** ++ * ChannelOwnerRemarked moderateComment. ++ * @member {IModerateComment|null|undefined} moderateComment ++ * @memberof ChannelOwnerRemarked ++ * @instance ++ */ ++ ChannelOwnerRemarked.prototype.moderateComment = null; ++ ++ // OneOf field names bound to virtual getters and setters ++ var $oneOfFields; ++ ++ /** ++ * ChannelOwnerRemarked channelOwnerRemarked. ++ * @member {"pinOrUnpinComment"|"banOrUnbanMemberFromChannel"|"videoReactionsPreference"|"moderateComment"|undefined} channelOwnerRemarked ++ * @memberof ChannelOwnerRemarked ++ * @instance ++ */ ++ Object.defineProperty(ChannelOwnerRemarked.prototype, "channelOwnerRemarked", { ++ get: $util.oneOfGetter($oneOfFields = ["pinOrUnpinComment", "banOrUnbanMemberFromChannel", "videoReactionsPreference", "moderateComment"]), ++ set: $util.oneOfSetter($oneOfFields) ++ }); ++ ++ /** ++ * Creates a new ChannelOwnerRemarked instance using the specified properties. ++ * @function create ++ * @memberof ChannelOwnerRemarked ++ * @static ++ * @param {IChannelOwnerRemarked=} [properties] Properties to set ++ * @returns {ChannelOwnerRemarked} ChannelOwnerRemarked instance ++ */ ++ ChannelOwnerRemarked.create = function create(properties) { ++ return new ChannelOwnerRemarked(properties); ++ }; ++ ++ /** ++ * Encodes the specified ChannelOwnerRemarked message. Does not implicitly {@link ChannelOwnerRemarked.verify|verify} messages. ++ * @function encode ++ * @memberof ChannelOwnerRemarked ++ * @static ++ * @param {IChannelOwnerRemarked} message ChannelOwnerRemarked message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ChannelOwnerRemarked.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.pinOrUnpinComment != null && Object.hasOwnProperty.call(message, "pinOrUnpinComment")) ++ $root.PinOrUnpinComment.encode(message.pinOrUnpinComment, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); ++ if (message.banOrUnbanMemberFromChannel != null && Object.hasOwnProperty.call(message, "banOrUnbanMemberFromChannel")) ++ $root.BanOrUnbanMemberFromChannel.encode(message.banOrUnbanMemberFromChannel, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); ++ if (message.videoReactionsPreference != null && Object.hasOwnProperty.call(message, "videoReactionsPreference")) ++ $root.VideoReactionsPreference.encode(message.videoReactionsPreference, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim(); ++ if (message.moderateComment != null && Object.hasOwnProperty.call(message, "moderateComment")) ++ $root.ModerateComment.encode(message.moderateComment, writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim(); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified ChannelOwnerRemarked message, length delimited. Does not implicitly {@link ChannelOwnerRemarked.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof ChannelOwnerRemarked ++ * @static ++ * @param {IChannelOwnerRemarked} message ChannelOwnerRemarked message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ChannelOwnerRemarked.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a ChannelOwnerRemarked message from the specified reader or buffer. ++ * @function decode ++ * @memberof ChannelOwnerRemarked ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {ChannelOwnerRemarked} ChannelOwnerRemarked ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ChannelOwnerRemarked.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ChannelOwnerRemarked(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.pinOrUnpinComment = $root.PinOrUnpinComment.decode(reader, reader.uint32()); ++ break; ++ case 2: ++ message.banOrUnbanMemberFromChannel = $root.BanOrUnbanMemberFromChannel.decode(reader, reader.uint32()); ++ break; ++ case 3: ++ message.videoReactionsPreference = $root.VideoReactionsPreference.decode(reader, reader.uint32()); ++ break; ++ case 5: ++ message.moderateComment = $root.ModerateComment.decode(reader, reader.uint32()); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a ChannelOwnerRemarked message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof ChannelOwnerRemarked ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {ChannelOwnerRemarked} ChannelOwnerRemarked ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ChannelOwnerRemarked.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a ChannelOwnerRemarked message. ++ * @function verify ++ * @memberof ChannelOwnerRemarked ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ ChannelOwnerRemarked.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ var properties = {}; ++ if (message.pinOrUnpinComment != null && message.hasOwnProperty("pinOrUnpinComment")) { ++ properties.channelOwnerRemarked = 1; ++ { ++ var error = $root.PinOrUnpinComment.verify(message.pinOrUnpinComment); ++ if (error) ++ return "pinOrUnpinComment." + error; ++ } ++ } ++ if (message.banOrUnbanMemberFromChannel != null && message.hasOwnProperty("banOrUnbanMemberFromChannel")) { ++ if (properties.channelOwnerRemarked === 1) ++ return "channelOwnerRemarked: multiple values"; ++ properties.channelOwnerRemarked = 1; ++ { ++ var error = $root.BanOrUnbanMemberFromChannel.verify(message.banOrUnbanMemberFromChannel); ++ if (error) ++ return "banOrUnbanMemberFromChannel." + error; ++ } ++ } ++ if (message.videoReactionsPreference != null && message.hasOwnProperty("videoReactionsPreference")) { ++ if (properties.channelOwnerRemarked === 1) ++ return "channelOwnerRemarked: multiple values"; ++ properties.channelOwnerRemarked = 1; ++ { ++ var error = $root.VideoReactionsPreference.verify(message.videoReactionsPreference); ++ if (error) ++ return "videoReactionsPreference." + error; ++ } ++ } ++ if (message.moderateComment != null && message.hasOwnProperty("moderateComment")) { ++ if (properties.channelOwnerRemarked === 1) ++ return "channelOwnerRemarked: multiple values"; ++ properties.channelOwnerRemarked = 1; ++ { ++ var error = $root.ModerateComment.verify(message.moderateComment); ++ if (error) ++ return "moderateComment." + error; ++ } ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates a ChannelOwnerRemarked message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof ChannelOwnerRemarked ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {ChannelOwnerRemarked} ChannelOwnerRemarked ++ */ ++ ChannelOwnerRemarked.fromObject = function fromObject(object) { ++ if (object instanceof $root.ChannelOwnerRemarked) ++ return object; ++ var message = new $root.ChannelOwnerRemarked(); ++ if (object.pinOrUnpinComment != null) { ++ if (typeof object.pinOrUnpinComment !== "object") ++ throw TypeError(".ChannelOwnerRemarked.pinOrUnpinComment: object expected"); ++ message.pinOrUnpinComment = $root.PinOrUnpinComment.fromObject(object.pinOrUnpinComment); ++ } ++ if (object.banOrUnbanMemberFromChannel != null) { ++ if (typeof object.banOrUnbanMemberFromChannel !== "object") ++ throw TypeError(".ChannelOwnerRemarked.banOrUnbanMemberFromChannel: object expected"); ++ message.banOrUnbanMemberFromChannel = $root.BanOrUnbanMemberFromChannel.fromObject(object.banOrUnbanMemberFromChannel); ++ } ++ if (object.videoReactionsPreference != null) { ++ if (typeof object.videoReactionsPreference !== "object") ++ throw TypeError(".ChannelOwnerRemarked.videoReactionsPreference: object expected"); ++ message.videoReactionsPreference = $root.VideoReactionsPreference.fromObject(object.videoReactionsPreference); ++ } ++ if (object.moderateComment != null) { ++ if (typeof object.moderateComment !== "object") ++ throw TypeError(".ChannelOwnerRemarked.moderateComment: object expected"); ++ message.moderateComment = $root.ModerateComment.fromObject(object.moderateComment); ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a ChannelOwnerRemarked message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof ChannelOwnerRemarked ++ * @static ++ * @param {ChannelOwnerRemarked} message ChannelOwnerRemarked ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ ChannelOwnerRemarked.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (message.pinOrUnpinComment != null && message.hasOwnProperty("pinOrUnpinComment")) { ++ object.pinOrUnpinComment = $root.PinOrUnpinComment.toObject(message.pinOrUnpinComment, options); ++ if (options.oneofs) ++ object.channelOwnerRemarked = "pinOrUnpinComment"; ++ } ++ if (message.banOrUnbanMemberFromChannel != null && message.hasOwnProperty("banOrUnbanMemberFromChannel")) { ++ object.banOrUnbanMemberFromChannel = $root.BanOrUnbanMemberFromChannel.toObject(message.banOrUnbanMemberFromChannel, options); ++ if (options.oneofs) ++ object.channelOwnerRemarked = "banOrUnbanMemberFromChannel"; ++ } ++ if (message.videoReactionsPreference != null && message.hasOwnProperty("videoReactionsPreference")) { ++ object.videoReactionsPreference = $root.VideoReactionsPreference.toObject(message.videoReactionsPreference, options); ++ if (options.oneofs) ++ object.channelOwnerRemarked = "videoReactionsPreference"; ++ } ++ if (message.moderateComment != null && message.hasOwnProperty("moderateComment")) { ++ object.moderateComment = $root.ModerateComment.toObject(message.moderateComment, options); ++ if (options.oneofs) ++ object.channelOwnerRemarked = "moderateComment"; ++ } ++ return object; ++ }; ++ ++ /** ++ * Converts this ChannelOwnerRemarked to JSON. ++ * @function toJSON ++ * @memberof ChannelOwnerRemarked ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ ChannelOwnerRemarked.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return ChannelOwnerRemarked; ++})(); ++ ++$root.PersonMetadata = (function() { ++ ++ /** ++ * Properties of a PersonMetadata. ++ * @exports IPersonMetadata ++ * @interface IPersonMetadata ++ * @property {string|null} [firstName] PersonMetadata firstName ++ * @property {string|null} [middleName] PersonMetadata middleName ++ * @property {string|null} [lastName] PersonMetadata lastName ++ * @property {string|null} [about] PersonMetadata about ++ * @property {number|null} [coverPhoto] PersonMetadata coverPhoto ++ * @property {number|null} [avatarPhoto] PersonMetadata avatarPhoto ++ */ ++ ++ /** ++ * Constructs a new PersonMetadata. ++ * @exports PersonMetadata ++ * @classdesc Represents a PersonMetadata. ++ * @implements IPersonMetadata ++ * @constructor ++ * @param {IPersonMetadata=} [properties] Properties to set ++ */ ++ function PersonMetadata(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * PersonMetadata firstName. ++ * @member {string} firstName ++ * @memberof PersonMetadata ++ * @instance ++ */ ++ PersonMetadata.prototype.firstName = ""; ++ ++ /** ++ * PersonMetadata middleName. ++ * @member {string} middleName ++ * @memberof PersonMetadata ++ * @instance ++ */ ++ PersonMetadata.prototype.middleName = ""; ++ ++ /** ++ * PersonMetadata lastName. ++ * @member {string} lastName ++ * @memberof PersonMetadata ++ * @instance ++ */ ++ PersonMetadata.prototype.lastName = ""; ++ ++ /** ++ * PersonMetadata about. ++ * @member {string} about ++ * @memberof PersonMetadata ++ * @instance ++ */ ++ PersonMetadata.prototype.about = ""; ++ ++ /** ++ * PersonMetadata coverPhoto. ++ * @member {number} coverPhoto ++ * @memberof PersonMetadata ++ * @instance ++ */ ++ PersonMetadata.prototype.coverPhoto = 0; ++ ++ /** ++ * PersonMetadata avatarPhoto. ++ * @member {number} avatarPhoto ++ * @memberof PersonMetadata ++ * @instance ++ */ ++ PersonMetadata.prototype.avatarPhoto = 0; ++ ++ /** ++ * Creates a new PersonMetadata instance using the specified properties. ++ * @function create ++ * @memberof PersonMetadata ++ * @static ++ * @param {IPersonMetadata=} [properties] Properties to set ++ * @returns {PersonMetadata} PersonMetadata instance ++ */ ++ PersonMetadata.create = function create(properties) { ++ return new PersonMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified PersonMetadata message. Does not implicitly {@link PersonMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof PersonMetadata ++ * @static ++ * @param {IPersonMetadata} message PersonMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ PersonMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.firstName != null && Object.hasOwnProperty.call(message, "firstName")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.firstName); ++ if (message.middleName != null && Object.hasOwnProperty.call(message, "middleName")) ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.middleName); ++ if (message.lastName != null && Object.hasOwnProperty.call(message, "lastName")) ++ writer.uint32(/* id 3, wireType 2 =*/26).string(message.lastName); ++ if (message.about != null && Object.hasOwnProperty.call(message, "about")) ++ writer.uint32(/* id 4, wireType 2 =*/34).string(message.about); ++ if (message.coverPhoto != null && Object.hasOwnProperty.call(message, "coverPhoto")) ++ writer.uint32(/* id 5, wireType 0 =*/40).uint32(message.coverPhoto); ++ if (message.avatarPhoto != null && Object.hasOwnProperty.call(message, "avatarPhoto")) ++ writer.uint32(/* id 6, wireType 0 =*/48).uint32(message.avatarPhoto); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified PersonMetadata message, length delimited. Does not implicitly {@link PersonMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof PersonMetadata ++ * @static ++ * @param {IPersonMetadata} message PersonMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ PersonMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a PersonMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof PersonMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {PersonMetadata} PersonMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ PersonMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.PersonMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.firstName = reader.string(); ++ break; ++ case 2: ++ message.middleName = reader.string(); ++ break; ++ case 3: ++ message.lastName = reader.string(); ++ break; ++ case 4: ++ message.about = reader.string(); ++ break; ++ case 5: ++ message.coverPhoto = reader.uint32(); ++ break; ++ case 6: ++ message.avatarPhoto = reader.uint32(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a PersonMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof PersonMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {PersonMetadata} PersonMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ PersonMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a PersonMetadata message. ++ * @function verify ++ * @memberof PersonMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ PersonMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.firstName != null && message.hasOwnProperty("firstName")) ++ if (!$util.isString(message.firstName)) ++ return "firstName: string expected"; ++ if (message.middleName != null && message.hasOwnProperty("middleName")) ++ if (!$util.isString(message.middleName)) ++ return "middleName: string expected"; ++ if (message.lastName != null && message.hasOwnProperty("lastName")) ++ if (!$util.isString(message.lastName)) ++ return "lastName: string expected"; ++ if (message.about != null && message.hasOwnProperty("about")) ++ if (!$util.isString(message.about)) ++ return "about: string expected"; ++ if (message.coverPhoto != null && message.hasOwnProperty("coverPhoto")) ++ if (!$util.isInteger(message.coverPhoto)) ++ return "coverPhoto: integer expected"; ++ if (message.avatarPhoto != null && message.hasOwnProperty("avatarPhoto")) ++ if (!$util.isInteger(message.avatarPhoto)) ++ return "avatarPhoto: integer expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a PersonMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof PersonMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {PersonMetadata} PersonMetadata ++ */ ++ PersonMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.PersonMetadata) ++ return object; ++ var message = new $root.PersonMetadata(); ++ if (object.firstName != null) ++ message.firstName = String(object.firstName); ++ if (object.middleName != null) ++ message.middleName = String(object.middleName); ++ if (object.lastName != null) ++ message.lastName = String(object.lastName); ++ if (object.about != null) ++ message.about = String(object.about); ++ if (object.coverPhoto != null) ++ message.coverPhoto = object.coverPhoto >>> 0; ++ if (object.avatarPhoto != null) ++ message.avatarPhoto = object.avatarPhoto >>> 0; ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a PersonMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof PersonMetadata ++ * @static ++ * @param {PersonMetadata} message PersonMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ PersonMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.firstName = ""; ++ object.middleName = ""; ++ object.lastName = ""; ++ object.about = ""; ++ object.coverPhoto = 0; ++ object.avatarPhoto = 0; ++ } ++ if (message.firstName != null && message.hasOwnProperty("firstName")) ++ object.firstName = message.firstName; ++ if (message.middleName != null && message.hasOwnProperty("middleName")) ++ object.middleName = message.middleName; ++ if (message.lastName != null && message.hasOwnProperty("lastName")) ++ object.lastName = message.lastName; ++ if (message.about != null && message.hasOwnProperty("about")) ++ object.about = message.about; ++ if (message.coverPhoto != null && message.hasOwnProperty("coverPhoto")) ++ object.coverPhoto = message.coverPhoto; ++ if (message.avatarPhoto != null && message.hasOwnProperty("avatarPhoto")) ++ object.avatarPhoto = message.avatarPhoto; ++ return object; ++ }; ++ ++ /** ++ * Converts this PersonMetadata to JSON. ++ * @function toJSON ++ * @memberof PersonMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ PersonMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return PersonMetadata; ++})(); ++ ++$root.ProposalsDiscussionPostMetadata = (function() { ++ ++ /** ++ * Properties of a ProposalsDiscussionPostMetadata. ++ * @exports IProposalsDiscussionPostMetadata ++ * @interface IProposalsDiscussionPostMetadata ++ * @property {string|null} [text] ProposalsDiscussionPostMetadata text ++ * @property {number|null} [repliesTo] ProposalsDiscussionPostMetadata repliesTo ++ */ ++ ++ /** ++ * Constructs a new ProposalsDiscussionPostMetadata. ++ * @exports ProposalsDiscussionPostMetadata ++ * @classdesc Represents a ProposalsDiscussionPostMetadata. ++ * @implements IProposalsDiscussionPostMetadata ++ * @constructor ++ * @param {IProposalsDiscussionPostMetadata=} [properties] Properties to set ++ */ ++ function ProposalsDiscussionPostMetadata(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * ProposalsDiscussionPostMetadata text. ++ * @member {string} text ++ * @memberof ProposalsDiscussionPostMetadata ++ * @instance ++ */ ++ ProposalsDiscussionPostMetadata.prototype.text = ""; ++ ++ /** ++ * ProposalsDiscussionPostMetadata repliesTo. ++ * @member {number} repliesTo ++ * @memberof ProposalsDiscussionPostMetadata ++ * @instance ++ */ ++ ProposalsDiscussionPostMetadata.prototype.repliesTo = 0; ++ ++ /** ++ * Creates a new ProposalsDiscussionPostMetadata instance using the specified properties. ++ * @function create ++ * @memberof ProposalsDiscussionPostMetadata ++ * @static ++ * @param {IProposalsDiscussionPostMetadata=} [properties] Properties to set ++ * @returns {ProposalsDiscussionPostMetadata} ProposalsDiscussionPostMetadata instance ++ */ ++ ProposalsDiscussionPostMetadata.create = function create(properties) { ++ return new ProposalsDiscussionPostMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified ProposalsDiscussionPostMetadata message. Does not implicitly {@link ProposalsDiscussionPostMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof ProposalsDiscussionPostMetadata ++ * @static ++ * @param {IProposalsDiscussionPostMetadata} message ProposalsDiscussionPostMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ProposalsDiscussionPostMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.text != null && Object.hasOwnProperty.call(message, "text")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.text); ++ if (message.repliesTo != null && Object.hasOwnProperty.call(message, "repliesTo")) ++ writer.uint32(/* id 2, wireType 0 =*/16).uint32(message.repliesTo); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified ProposalsDiscussionPostMetadata message, length delimited. Does not implicitly {@link ProposalsDiscussionPostMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof ProposalsDiscussionPostMetadata ++ * @static ++ * @param {IProposalsDiscussionPostMetadata} message ProposalsDiscussionPostMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ProposalsDiscussionPostMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a ProposalsDiscussionPostMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof ProposalsDiscussionPostMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {ProposalsDiscussionPostMetadata} ProposalsDiscussionPostMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ProposalsDiscussionPostMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ProposalsDiscussionPostMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.text = reader.string(); ++ break; ++ case 2: ++ message.repliesTo = reader.uint32(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a ProposalsDiscussionPostMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof ProposalsDiscussionPostMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {ProposalsDiscussionPostMetadata} ProposalsDiscussionPostMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ProposalsDiscussionPostMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a ProposalsDiscussionPostMetadata message. ++ * @function verify ++ * @memberof ProposalsDiscussionPostMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ ProposalsDiscussionPostMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.text != null && message.hasOwnProperty("text")) ++ if (!$util.isString(message.text)) ++ return "text: string expected"; ++ if (message.repliesTo != null && message.hasOwnProperty("repliesTo")) ++ if (!$util.isInteger(message.repliesTo)) ++ return "repliesTo: integer expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a ProposalsDiscussionPostMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof ProposalsDiscussionPostMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {ProposalsDiscussionPostMetadata} ProposalsDiscussionPostMetadata ++ */ ++ ProposalsDiscussionPostMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.ProposalsDiscussionPostMetadata) ++ return object; ++ var message = new $root.ProposalsDiscussionPostMetadata(); ++ if (object.text != null) ++ message.text = String(object.text); ++ if (object.repliesTo != null) ++ message.repliesTo = object.repliesTo >>> 0; ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a ProposalsDiscussionPostMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof ProposalsDiscussionPostMetadata ++ * @static ++ * @param {ProposalsDiscussionPostMetadata} message ProposalsDiscussionPostMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ ProposalsDiscussionPostMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.text = ""; ++ object.repliesTo = 0; ++ } ++ if (message.text != null && message.hasOwnProperty("text")) ++ object.text = message.text; ++ if (message.repliesTo != null && message.hasOwnProperty("repliesTo")) ++ object.repliesTo = message.repliesTo; ++ return object; ++ }; ++ ++ /** ++ * Converts this ProposalsDiscussionPostMetadata to JSON. ++ * @function toJSON ++ * @memberof ProposalsDiscussionPostMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ ProposalsDiscussionPostMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return ProposalsDiscussionPostMetadata; ++})(); ++ ++$root.SeriesMetadata = (function() { ++ ++ /** ++ * Properties of a SeriesMetadata. ++ * @exports ISeriesMetadata ++ * @interface ISeriesMetadata ++ * @property {string|null} [title] SeriesMetadata title ++ * @property {string|null} [description] SeriesMetadata description ++ * @property {number|null} [coverPhoto] SeriesMetadata coverPhoto ++ * @property {Array.|null} [persons] SeriesMetadata persons ++ */ ++ ++ /** ++ * Constructs a new SeriesMetadata. ++ * @exports SeriesMetadata ++ * @classdesc Represents a SeriesMetadata. ++ * @implements ISeriesMetadata ++ * @constructor ++ * @param {ISeriesMetadata=} [properties] Properties to set ++ */ ++ function SeriesMetadata(properties) { ++ this.persons = []; ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * SeriesMetadata title. ++ * @member {string} title ++ * @memberof SeriesMetadata ++ * @instance ++ */ ++ SeriesMetadata.prototype.title = ""; ++ ++ /** ++ * SeriesMetadata description. ++ * @member {string} description ++ * @memberof SeriesMetadata ++ * @instance ++ */ ++ SeriesMetadata.prototype.description = ""; ++ ++ /** ++ * SeriesMetadata coverPhoto. ++ * @member {number} coverPhoto ++ * @memberof SeriesMetadata ++ * @instance ++ */ ++ SeriesMetadata.prototype.coverPhoto = 0; ++ ++ /** ++ * SeriesMetadata persons. ++ * @member {Array.} persons ++ * @memberof SeriesMetadata ++ * @instance ++ */ ++ SeriesMetadata.prototype.persons = $util.emptyArray; ++ ++ /** ++ * Creates a new SeriesMetadata instance using the specified properties. ++ * @function create ++ * @memberof SeriesMetadata ++ * @static ++ * @param {ISeriesMetadata=} [properties] Properties to set ++ * @returns {SeriesMetadata} SeriesMetadata instance ++ */ ++ SeriesMetadata.create = function create(properties) { ++ return new SeriesMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified SeriesMetadata message. Does not implicitly {@link SeriesMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof SeriesMetadata ++ * @static ++ * @param {ISeriesMetadata} message SeriesMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ SeriesMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.title != null && Object.hasOwnProperty.call(message, "title")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.title); ++ if (message.description != null && Object.hasOwnProperty.call(message, "description")) ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.description); ++ if (message.coverPhoto != null && Object.hasOwnProperty.call(message, "coverPhoto")) ++ writer.uint32(/* id 3, wireType 0 =*/24).uint32(message.coverPhoto); ++ if (message.persons != null && message.persons.length) { ++ writer.uint32(/* id 4, wireType 2 =*/34).fork(); ++ for (var i = 0; i < message.persons.length; ++i) ++ writer.uint64(message.persons[i]); ++ writer.ldelim(); ++ } ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified SeriesMetadata message, length delimited. Does not implicitly {@link SeriesMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof SeriesMetadata ++ * @static ++ * @param {ISeriesMetadata} message SeriesMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ SeriesMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a SeriesMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof SeriesMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {SeriesMetadata} SeriesMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ SeriesMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.SeriesMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.title = reader.string(); ++ break; ++ case 2: ++ message.description = reader.string(); ++ break; ++ case 3: ++ message.coverPhoto = reader.uint32(); ++ break; ++ case 4: ++ if (!(message.persons && message.persons.length)) ++ message.persons = []; ++ if ((tag & 7) === 2) { ++ var end2 = reader.uint32() + reader.pos; ++ while (reader.pos < end2) ++ message.persons.push(reader.uint64()); ++ } else ++ message.persons.push(reader.uint64()); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a SeriesMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof SeriesMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {SeriesMetadata} SeriesMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ SeriesMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a SeriesMetadata message. ++ * @function verify ++ * @memberof SeriesMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ SeriesMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.title != null && message.hasOwnProperty("title")) ++ if (!$util.isString(message.title)) ++ return "title: string expected"; ++ if (message.description != null && message.hasOwnProperty("description")) ++ if (!$util.isString(message.description)) ++ return "description: string expected"; ++ if (message.coverPhoto != null && message.hasOwnProperty("coverPhoto")) ++ if (!$util.isInteger(message.coverPhoto)) ++ return "coverPhoto: integer expected"; ++ if (message.persons != null && message.hasOwnProperty("persons")) { ++ if (!Array.isArray(message.persons)) ++ return "persons: array expected"; ++ for (var i = 0; i < message.persons.length; ++i) ++ if (!$util.isInteger(message.persons[i]) && !(message.persons[i] && $util.isInteger(message.persons[i].low) && $util.isInteger(message.persons[i].high))) ++ return "persons: integer|Long[] expected"; ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates a SeriesMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof SeriesMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {SeriesMetadata} SeriesMetadata ++ */ ++ SeriesMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.SeriesMetadata) ++ return object; ++ var message = new $root.SeriesMetadata(); ++ if (object.title != null) ++ message.title = String(object.title); ++ if (object.description != null) ++ message.description = String(object.description); ++ if (object.coverPhoto != null) ++ message.coverPhoto = object.coverPhoto >>> 0; ++ if (object.persons) { ++ if (!Array.isArray(object.persons)) ++ throw TypeError(".SeriesMetadata.persons: array expected"); ++ message.persons = []; ++ for (var i = 0; i < object.persons.length; ++i) ++ if ($util.Long) ++ (message.persons[i] = $util.Long.fromValue(object.persons[i])).unsigned = true; ++ else if (typeof object.persons[i] === "string") ++ message.persons[i] = parseInt(object.persons[i], 10); ++ else if (typeof object.persons[i] === "number") ++ message.persons[i] = object.persons[i]; ++ else if (typeof object.persons[i] === "object") ++ message.persons[i] = new $util.LongBits(object.persons[i].low >>> 0, object.persons[i].high >>> 0).toNumber(true); ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a SeriesMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof SeriesMetadata ++ * @static ++ * @param {SeriesMetadata} message SeriesMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ SeriesMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.arrays || options.defaults) ++ object.persons = []; ++ if (options.defaults) { ++ object.title = ""; ++ object.description = ""; ++ object.coverPhoto = 0; ++ } ++ if (message.title != null && message.hasOwnProperty("title")) ++ object.title = message.title; ++ if (message.description != null && message.hasOwnProperty("description")) ++ object.description = message.description; ++ if (message.coverPhoto != null && message.hasOwnProperty("coverPhoto")) ++ object.coverPhoto = message.coverPhoto; ++ if (message.persons && message.persons.length) { ++ object.persons = []; ++ for (var j = 0; j < message.persons.length; ++j) ++ if (typeof message.persons[j] === "number") ++ object.persons[j] = options.longs === String ? String(message.persons[j]) : message.persons[j]; ++ else ++ object.persons[j] = options.longs === String ? $util.Long.prototype.toString.call(message.persons[j]) : options.longs === Number ? new $util.LongBits(message.persons[j].low >>> 0, message.persons[j].high >>> 0).toNumber(true) : message.persons[j]; ++ } ++ return object; ++ }; ++ ++ /** ++ * Converts this SeriesMetadata to JSON. ++ * @function toJSON ++ * @memberof SeriesMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ SeriesMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return SeriesMetadata; ++})(); ++ ++$root.SeasonMetadata = (function() { ++ ++ /** ++ * Properties of a SeasonMetadata. ++ * @exports ISeasonMetadata ++ * @interface ISeasonMetadata ++ * @property {string|null} [title] SeasonMetadata title ++ * @property {string|null} [description] SeasonMetadata description ++ * @property {number|null} [coverPhoto] SeasonMetadata coverPhoto ++ * @property {Array.|null} [persons] SeasonMetadata persons ++ */ ++ ++ /** ++ * Constructs a new SeasonMetadata. ++ * @exports SeasonMetadata ++ * @classdesc Represents a SeasonMetadata. ++ * @implements ISeasonMetadata ++ * @constructor ++ * @param {ISeasonMetadata=} [properties] Properties to set ++ */ ++ function SeasonMetadata(properties) { ++ this.persons = []; ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * SeasonMetadata title. ++ * @member {string} title ++ * @memberof SeasonMetadata ++ * @instance ++ */ ++ SeasonMetadata.prototype.title = ""; ++ ++ /** ++ * SeasonMetadata description. ++ * @member {string} description ++ * @memberof SeasonMetadata ++ * @instance ++ */ ++ SeasonMetadata.prototype.description = ""; ++ ++ /** ++ * SeasonMetadata coverPhoto. ++ * @member {number} coverPhoto ++ * @memberof SeasonMetadata ++ * @instance ++ */ ++ SeasonMetadata.prototype.coverPhoto = 0; ++ ++ /** ++ * SeasonMetadata persons. ++ * @member {Array.} persons ++ * @memberof SeasonMetadata ++ * @instance ++ */ ++ SeasonMetadata.prototype.persons = $util.emptyArray; ++ ++ /** ++ * Creates a new SeasonMetadata instance using the specified properties. ++ * @function create ++ * @memberof SeasonMetadata ++ * @static ++ * @param {ISeasonMetadata=} [properties] Properties to set ++ * @returns {SeasonMetadata} SeasonMetadata instance ++ */ ++ SeasonMetadata.create = function create(properties) { ++ return new SeasonMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified SeasonMetadata message. Does not implicitly {@link SeasonMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof SeasonMetadata ++ * @static ++ * @param {ISeasonMetadata} message SeasonMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ SeasonMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.title != null && Object.hasOwnProperty.call(message, "title")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.title); ++ if (message.description != null && Object.hasOwnProperty.call(message, "description")) ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.description); ++ if (message.coverPhoto != null && Object.hasOwnProperty.call(message, "coverPhoto")) ++ writer.uint32(/* id 3, wireType 0 =*/24).uint32(message.coverPhoto); ++ if (message.persons != null && message.persons.length) { ++ writer.uint32(/* id 4, wireType 2 =*/34).fork(); ++ for (var i = 0; i < message.persons.length; ++i) ++ writer.uint64(message.persons[i]); ++ writer.ldelim(); ++ } ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified SeasonMetadata message, length delimited. Does not implicitly {@link SeasonMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof SeasonMetadata ++ * @static ++ * @param {ISeasonMetadata} message SeasonMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ SeasonMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a SeasonMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof SeasonMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {SeasonMetadata} SeasonMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ SeasonMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.SeasonMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.title = reader.string(); ++ break; ++ case 2: ++ message.description = reader.string(); ++ break; ++ case 3: ++ message.coverPhoto = reader.uint32(); ++ break; ++ case 4: ++ if (!(message.persons && message.persons.length)) ++ message.persons = []; ++ if ((tag & 7) === 2) { ++ var end2 = reader.uint32() + reader.pos; ++ while (reader.pos < end2) ++ message.persons.push(reader.uint64()); ++ } else ++ message.persons.push(reader.uint64()); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a SeasonMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof SeasonMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {SeasonMetadata} SeasonMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ SeasonMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a SeasonMetadata message. ++ * @function verify ++ * @memberof SeasonMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ SeasonMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.title != null && message.hasOwnProperty("title")) ++ if (!$util.isString(message.title)) ++ return "title: string expected"; ++ if (message.description != null && message.hasOwnProperty("description")) ++ if (!$util.isString(message.description)) ++ return "description: string expected"; ++ if (message.coverPhoto != null && message.hasOwnProperty("coverPhoto")) ++ if (!$util.isInteger(message.coverPhoto)) ++ return "coverPhoto: integer expected"; ++ if (message.persons != null && message.hasOwnProperty("persons")) { ++ if (!Array.isArray(message.persons)) ++ return "persons: array expected"; ++ for (var i = 0; i < message.persons.length; ++i) ++ if (!$util.isInteger(message.persons[i]) && !(message.persons[i] && $util.isInteger(message.persons[i].low) && $util.isInteger(message.persons[i].high))) ++ return "persons: integer|Long[] expected"; ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates a SeasonMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof SeasonMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {SeasonMetadata} SeasonMetadata ++ */ ++ SeasonMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.SeasonMetadata) ++ return object; ++ var message = new $root.SeasonMetadata(); ++ if (object.title != null) ++ message.title = String(object.title); ++ if (object.description != null) ++ message.description = String(object.description); ++ if (object.coverPhoto != null) ++ message.coverPhoto = object.coverPhoto >>> 0; ++ if (object.persons) { ++ if (!Array.isArray(object.persons)) ++ throw TypeError(".SeasonMetadata.persons: array expected"); ++ message.persons = []; ++ for (var i = 0; i < object.persons.length; ++i) ++ if ($util.Long) ++ (message.persons[i] = $util.Long.fromValue(object.persons[i])).unsigned = true; ++ else if (typeof object.persons[i] === "string") ++ message.persons[i] = parseInt(object.persons[i], 10); ++ else if (typeof object.persons[i] === "number") ++ message.persons[i] = object.persons[i]; ++ else if (typeof object.persons[i] === "object") ++ message.persons[i] = new $util.LongBits(object.persons[i].low >>> 0, object.persons[i].high >>> 0).toNumber(true); ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a SeasonMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof SeasonMetadata ++ * @static ++ * @param {SeasonMetadata} message SeasonMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ SeasonMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.arrays || options.defaults) ++ object.persons = []; ++ if (options.defaults) { ++ object.title = ""; ++ object.description = ""; ++ object.coverPhoto = 0; ++ } ++ if (message.title != null && message.hasOwnProperty("title")) ++ object.title = message.title; ++ if (message.description != null && message.hasOwnProperty("description")) ++ object.description = message.description; ++ if (message.coverPhoto != null && message.hasOwnProperty("coverPhoto")) ++ object.coverPhoto = message.coverPhoto; ++ if (message.persons && message.persons.length) { ++ object.persons = []; ++ for (var j = 0; j < message.persons.length; ++j) ++ if (typeof message.persons[j] === "number") ++ object.persons[j] = options.longs === String ? String(message.persons[j]) : message.persons[j]; ++ else ++ object.persons[j] = options.longs === String ? $util.Long.prototype.toString.call(message.persons[j]) : options.longs === Number ? new $util.LongBits(message.persons[j].low >>> 0, message.persons[j].high >>> 0).toNumber(true) : message.persons[j]; ++ } ++ return object; ++ }; ++ ++ /** ++ * Converts this SeasonMetadata to JSON. ++ * @function toJSON ++ * @memberof SeasonMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ SeasonMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return SeasonMetadata; ++})(); ++ ++$root.GeoCoordiantes = (function() { ++ ++ /** ++ * Properties of a GeoCoordiantes. ++ * @exports IGeoCoordiantes ++ * @interface IGeoCoordiantes ++ * @property {number|null} [latitude] GeoCoordiantes latitude ++ * @property {number|null} [longitude] GeoCoordiantes longitude ++ */ ++ ++ /** ++ * Constructs a new GeoCoordiantes. ++ * @exports GeoCoordiantes ++ * @classdesc Represents a GeoCoordiantes. ++ * @implements IGeoCoordiantes ++ * @constructor ++ * @param {IGeoCoordiantes=} [properties] Properties to set ++ */ ++ function GeoCoordiantes(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * GeoCoordiantes latitude. ++ * @member {number} latitude ++ * @memberof GeoCoordiantes ++ * @instance ++ */ ++ GeoCoordiantes.prototype.latitude = 0; ++ ++ /** ++ * GeoCoordiantes longitude. ++ * @member {number} longitude ++ * @memberof GeoCoordiantes ++ * @instance ++ */ ++ GeoCoordiantes.prototype.longitude = 0; ++ ++ /** ++ * Creates a new GeoCoordiantes instance using the specified properties. ++ * @function create ++ * @memberof GeoCoordiantes ++ * @static ++ * @param {IGeoCoordiantes=} [properties] Properties to set ++ * @returns {GeoCoordiantes} GeoCoordiantes instance ++ */ ++ GeoCoordiantes.create = function create(properties) { ++ return new GeoCoordiantes(properties); ++ }; ++ ++ /** ++ * Encodes the specified GeoCoordiantes message. Does not implicitly {@link GeoCoordiantes.verify|verify} messages. ++ * @function encode ++ * @memberof GeoCoordiantes ++ * @static ++ * @param {IGeoCoordiantes} message GeoCoordiantes message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ GeoCoordiantes.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.latitude != null && Object.hasOwnProperty.call(message, "latitude")) ++ writer.uint32(/* id 3, wireType 5 =*/29).float(message.latitude); ++ if (message.longitude != null && Object.hasOwnProperty.call(message, "longitude")) ++ writer.uint32(/* id 4, wireType 5 =*/37).float(message.longitude); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified GeoCoordiantes message, length delimited. Does not implicitly {@link GeoCoordiantes.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof GeoCoordiantes ++ * @static ++ * @param {IGeoCoordiantes} message GeoCoordiantes message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ GeoCoordiantes.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a GeoCoordiantes message from the specified reader or buffer. ++ * @function decode ++ * @memberof GeoCoordiantes ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {GeoCoordiantes} GeoCoordiantes ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ GeoCoordiantes.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.GeoCoordiantes(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 3: ++ message.latitude = reader.float(); ++ break; ++ case 4: ++ message.longitude = reader.float(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a GeoCoordiantes message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof GeoCoordiantes ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {GeoCoordiantes} GeoCoordiantes ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ GeoCoordiantes.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a GeoCoordiantes message. ++ * @function verify ++ * @memberof GeoCoordiantes ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ GeoCoordiantes.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.latitude != null && message.hasOwnProperty("latitude")) ++ if (typeof message.latitude !== "number") ++ return "latitude: number expected"; ++ if (message.longitude != null && message.hasOwnProperty("longitude")) ++ if (typeof message.longitude !== "number") ++ return "longitude: number expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a GeoCoordiantes message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof GeoCoordiantes ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {GeoCoordiantes} GeoCoordiantes ++ */ ++ GeoCoordiantes.fromObject = function fromObject(object) { ++ if (object instanceof $root.GeoCoordiantes) ++ return object; ++ var message = new $root.GeoCoordiantes(); ++ if (object.latitude != null) ++ message.latitude = Number(object.latitude); ++ if (object.longitude != null) ++ message.longitude = Number(object.longitude); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a GeoCoordiantes message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof GeoCoordiantes ++ * @static ++ * @param {GeoCoordiantes} message GeoCoordiantes ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ GeoCoordiantes.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.latitude = 0; ++ object.longitude = 0; ++ } ++ if (message.latitude != null && message.hasOwnProperty("latitude")) ++ object.latitude = options.json && !isFinite(message.latitude) ? String(message.latitude) : message.latitude; ++ if (message.longitude != null && message.hasOwnProperty("longitude")) ++ object.longitude = options.json && !isFinite(message.longitude) ? String(message.longitude) : message.longitude; ++ return object; ++ }; ++ ++ /** ++ * Converts this GeoCoordiantes to JSON. ++ * @function toJSON ++ * @memberof GeoCoordiantes ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ GeoCoordiantes.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return GeoCoordiantes; ++})(); ++ ++$root.NodeLocationMetadata = (function() { ++ ++ /** ++ * Properties of a NodeLocationMetadata. ++ * @exports INodeLocationMetadata ++ * @interface INodeLocationMetadata ++ * @property {string|null} [countryCode] NodeLocationMetadata countryCode ++ * @property {string|null} [city] NodeLocationMetadata city ++ * @property {IGeoCoordiantes|null} [coordinates] NodeLocationMetadata coordinates ++ */ ++ ++ /** ++ * Constructs a new NodeLocationMetadata. ++ * @exports NodeLocationMetadata ++ * @classdesc Represents a NodeLocationMetadata. ++ * @implements INodeLocationMetadata ++ * @constructor ++ * @param {INodeLocationMetadata=} [properties] Properties to set ++ */ ++ function NodeLocationMetadata(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * NodeLocationMetadata countryCode. ++ * @member {string} countryCode ++ * @memberof NodeLocationMetadata ++ * @instance ++ */ ++ NodeLocationMetadata.prototype.countryCode = ""; ++ ++ /** ++ * NodeLocationMetadata city. ++ * @member {string} city ++ * @memberof NodeLocationMetadata ++ * @instance ++ */ ++ NodeLocationMetadata.prototype.city = ""; ++ ++ /** ++ * NodeLocationMetadata coordinates. ++ * @member {IGeoCoordiantes|null|undefined} coordinates ++ * @memberof NodeLocationMetadata ++ * @instance ++ */ ++ NodeLocationMetadata.prototype.coordinates = null; ++ ++ /** ++ * Creates a new NodeLocationMetadata instance using the specified properties. ++ * @function create ++ * @memberof NodeLocationMetadata ++ * @static ++ * @param {INodeLocationMetadata=} [properties] Properties to set ++ * @returns {NodeLocationMetadata} NodeLocationMetadata instance ++ */ ++ NodeLocationMetadata.create = function create(properties) { ++ return new NodeLocationMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified NodeLocationMetadata message. Does not implicitly {@link NodeLocationMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof NodeLocationMetadata ++ * @static ++ * @param {INodeLocationMetadata} message NodeLocationMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ NodeLocationMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.countryCode != null && Object.hasOwnProperty.call(message, "countryCode")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.countryCode); ++ if (message.city != null && Object.hasOwnProperty.call(message, "city")) ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.city); ++ if (message.coordinates != null && Object.hasOwnProperty.call(message, "coordinates")) ++ $root.GeoCoordiantes.encode(message.coordinates, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim(); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified NodeLocationMetadata message, length delimited. Does not implicitly {@link NodeLocationMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof NodeLocationMetadata ++ * @static ++ * @param {INodeLocationMetadata} message NodeLocationMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ NodeLocationMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a NodeLocationMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof NodeLocationMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {NodeLocationMetadata} NodeLocationMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ NodeLocationMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.NodeLocationMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.countryCode = reader.string(); ++ break; ++ case 2: ++ message.city = reader.string(); ++ break; ++ case 3: ++ message.coordinates = $root.GeoCoordiantes.decode(reader, reader.uint32()); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a NodeLocationMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof NodeLocationMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {NodeLocationMetadata} NodeLocationMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ NodeLocationMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a NodeLocationMetadata message. ++ * @function verify ++ * @memberof NodeLocationMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ NodeLocationMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.countryCode != null && message.hasOwnProperty("countryCode")) ++ if (!$util.isString(message.countryCode)) ++ return "countryCode: string expected"; ++ if (message.city != null && message.hasOwnProperty("city")) ++ if (!$util.isString(message.city)) ++ return "city: string expected"; ++ if (message.coordinates != null && message.hasOwnProperty("coordinates")) { ++ var error = $root.GeoCoordiantes.verify(message.coordinates); ++ if (error) ++ return "coordinates." + error; ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates a NodeLocationMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof NodeLocationMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {NodeLocationMetadata} NodeLocationMetadata ++ */ ++ NodeLocationMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.NodeLocationMetadata) ++ return object; ++ var message = new $root.NodeLocationMetadata(); ++ if (object.countryCode != null) ++ message.countryCode = String(object.countryCode); ++ if (object.city != null) ++ message.city = String(object.city); ++ if (object.coordinates != null) { ++ if (typeof object.coordinates !== "object") ++ throw TypeError(".NodeLocationMetadata.coordinates: object expected"); ++ message.coordinates = $root.GeoCoordiantes.fromObject(object.coordinates); ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a NodeLocationMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof NodeLocationMetadata ++ * @static ++ * @param {NodeLocationMetadata} message NodeLocationMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ NodeLocationMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.countryCode = ""; ++ object.city = ""; ++ object.coordinates = null; ++ } ++ if (message.countryCode != null && message.hasOwnProperty("countryCode")) ++ object.countryCode = message.countryCode; ++ if (message.city != null && message.hasOwnProperty("city")) ++ object.city = message.city; ++ if (message.coordinates != null && message.hasOwnProperty("coordinates")) ++ object.coordinates = $root.GeoCoordiantes.toObject(message.coordinates, options); ++ return object; ++ }; ++ ++ /** ++ * Converts this NodeLocationMetadata to JSON. ++ * @function toJSON ++ * @memberof NodeLocationMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ NodeLocationMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return NodeLocationMetadata; ++})(); ++ ++$root.StorageBucketOperatorMetadata = (function() { ++ ++ /** ++ * Properties of a StorageBucketOperatorMetadata. ++ * @exports IStorageBucketOperatorMetadata ++ * @interface IStorageBucketOperatorMetadata ++ * @property {string|null} [endpoint] StorageBucketOperatorMetadata endpoint ++ * @property {INodeLocationMetadata|null} [location] StorageBucketOperatorMetadata location ++ * @property {string|null} [extra] StorageBucketOperatorMetadata extra ++ */ ++ ++ /** ++ * Constructs a new StorageBucketOperatorMetadata. ++ * @exports StorageBucketOperatorMetadata ++ * @classdesc Represents a StorageBucketOperatorMetadata. ++ * @implements IStorageBucketOperatorMetadata ++ * @constructor ++ * @param {IStorageBucketOperatorMetadata=} [properties] Properties to set ++ */ ++ function StorageBucketOperatorMetadata(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * StorageBucketOperatorMetadata endpoint. ++ * @member {string} endpoint ++ * @memberof StorageBucketOperatorMetadata ++ * @instance ++ */ ++ StorageBucketOperatorMetadata.prototype.endpoint = ""; ++ ++ /** ++ * StorageBucketOperatorMetadata location. ++ * @member {INodeLocationMetadata|null|undefined} location ++ * @memberof StorageBucketOperatorMetadata ++ * @instance ++ */ ++ StorageBucketOperatorMetadata.prototype.location = null; ++ ++ /** ++ * StorageBucketOperatorMetadata extra. ++ * @member {string} extra ++ * @memberof StorageBucketOperatorMetadata ++ * @instance ++ */ ++ StorageBucketOperatorMetadata.prototype.extra = ""; ++ ++ /** ++ * Creates a new StorageBucketOperatorMetadata instance using the specified properties. ++ * @function create ++ * @memberof StorageBucketOperatorMetadata ++ * @static ++ * @param {IStorageBucketOperatorMetadata=} [properties] Properties to set ++ * @returns {StorageBucketOperatorMetadata} StorageBucketOperatorMetadata instance ++ */ ++ StorageBucketOperatorMetadata.create = function create(properties) { ++ return new StorageBucketOperatorMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified StorageBucketOperatorMetadata message. Does not implicitly {@link StorageBucketOperatorMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof StorageBucketOperatorMetadata ++ * @static ++ * @param {IStorageBucketOperatorMetadata} message StorageBucketOperatorMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ StorageBucketOperatorMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.endpoint != null && Object.hasOwnProperty.call(message, "endpoint")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.endpoint); ++ if (message.location != null && Object.hasOwnProperty.call(message, "location")) ++ $root.NodeLocationMetadata.encode(message.location, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); ++ if (message.extra != null && Object.hasOwnProperty.call(message, "extra")) ++ writer.uint32(/* id 3, wireType 2 =*/26).string(message.extra); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified StorageBucketOperatorMetadata message, length delimited. Does not implicitly {@link StorageBucketOperatorMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof StorageBucketOperatorMetadata ++ * @static ++ * @param {IStorageBucketOperatorMetadata} message StorageBucketOperatorMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ StorageBucketOperatorMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a StorageBucketOperatorMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof StorageBucketOperatorMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {StorageBucketOperatorMetadata} StorageBucketOperatorMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ StorageBucketOperatorMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.StorageBucketOperatorMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.endpoint = reader.string(); ++ break; ++ case 2: ++ message.location = $root.NodeLocationMetadata.decode(reader, reader.uint32()); ++ break; ++ case 3: ++ message.extra = reader.string(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a StorageBucketOperatorMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof StorageBucketOperatorMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {StorageBucketOperatorMetadata} StorageBucketOperatorMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ StorageBucketOperatorMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a StorageBucketOperatorMetadata message. ++ * @function verify ++ * @memberof StorageBucketOperatorMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ StorageBucketOperatorMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.endpoint != null && message.hasOwnProperty("endpoint")) ++ if (!$util.isString(message.endpoint)) ++ return "endpoint: string expected"; ++ if (message.location != null && message.hasOwnProperty("location")) { ++ var error = $root.NodeLocationMetadata.verify(message.location); ++ if (error) ++ return "location." + error; ++ } ++ if (message.extra != null && message.hasOwnProperty("extra")) ++ if (!$util.isString(message.extra)) ++ return "extra: string expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a StorageBucketOperatorMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof StorageBucketOperatorMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {StorageBucketOperatorMetadata} StorageBucketOperatorMetadata ++ */ ++ StorageBucketOperatorMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.StorageBucketOperatorMetadata) ++ return object; ++ var message = new $root.StorageBucketOperatorMetadata(); ++ if (object.endpoint != null) ++ message.endpoint = String(object.endpoint); ++ if (object.location != null) { ++ if (typeof object.location !== "object") ++ throw TypeError(".StorageBucketOperatorMetadata.location: object expected"); ++ message.location = $root.NodeLocationMetadata.fromObject(object.location); ++ } ++ if (object.extra != null) ++ message.extra = String(object.extra); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a StorageBucketOperatorMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof StorageBucketOperatorMetadata ++ * @static ++ * @param {StorageBucketOperatorMetadata} message StorageBucketOperatorMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ StorageBucketOperatorMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.endpoint = ""; ++ object.location = null; ++ object.extra = ""; ++ } ++ if (message.endpoint != null && message.hasOwnProperty("endpoint")) ++ object.endpoint = message.endpoint; ++ if (message.location != null && message.hasOwnProperty("location")) ++ object.location = $root.NodeLocationMetadata.toObject(message.location, options); ++ if (message.extra != null && message.hasOwnProperty("extra")) ++ object.extra = message.extra; ++ return object; ++ }; ++ ++ /** ++ * Converts this StorageBucketOperatorMetadata to JSON. ++ * @function toJSON ++ * @memberof StorageBucketOperatorMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ StorageBucketOperatorMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return StorageBucketOperatorMetadata; ++})(); ++ ++$root.DistributionBucketOperatorMetadata = (function() { ++ ++ /** ++ * Properties of a DistributionBucketOperatorMetadata. ++ * @exports IDistributionBucketOperatorMetadata ++ * @interface IDistributionBucketOperatorMetadata ++ * @property {string|null} [endpoint] DistributionBucketOperatorMetadata endpoint ++ * @property {INodeLocationMetadata|null} [location] DistributionBucketOperatorMetadata location ++ * @property {string|null} [extra] DistributionBucketOperatorMetadata extra ++ */ ++ ++ /** ++ * Constructs a new DistributionBucketOperatorMetadata. ++ * @exports DistributionBucketOperatorMetadata ++ * @classdesc Represents a DistributionBucketOperatorMetadata. ++ * @implements IDistributionBucketOperatorMetadata ++ * @constructor ++ * @param {IDistributionBucketOperatorMetadata=} [properties] Properties to set ++ */ ++ function DistributionBucketOperatorMetadata(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * DistributionBucketOperatorMetadata endpoint. ++ * @member {string} endpoint ++ * @memberof DistributionBucketOperatorMetadata ++ * @instance ++ */ ++ DistributionBucketOperatorMetadata.prototype.endpoint = ""; ++ ++ /** ++ * DistributionBucketOperatorMetadata location. ++ * @member {INodeLocationMetadata|null|undefined} location ++ * @memberof DistributionBucketOperatorMetadata ++ * @instance ++ */ ++ DistributionBucketOperatorMetadata.prototype.location = null; ++ ++ /** ++ * DistributionBucketOperatorMetadata extra. ++ * @member {string} extra ++ * @memberof DistributionBucketOperatorMetadata ++ * @instance ++ */ ++ DistributionBucketOperatorMetadata.prototype.extra = ""; ++ ++ /** ++ * Creates a new DistributionBucketOperatorMetadata instance using the specified properties. ++ * @function create ++ * @memberof DistributionBucketOperatorMetadata ++ * @static ++ * @param {IDistributionBucketOperatorMetadata=} [properties] Properties to set ++ * @returns {DistributionBucketOperatorMetadata} DistributionBucketOperatorMetadata instance ++ */ ++ DistributionBucketOperatorMetadata.create = function create(properties) { ++ return new DistributionBucketOperatorMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified DistributionBucketOperatorMetadata message. Does not implicitly {@link DistributionBucketOperatorMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof DistributionBucketOperatorMetadata ++ * @static ++ * @param {IDistributionBucketOperatorMetadata} message DistributionBucketOperatorMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ DistributionBucketOperatorMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.endpoint != null && Object.hasOwnProperty.call(message, "endpoint")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.endpoint); ++ if (message.location != null && Object.hasOwnProperty.call(message, "location")) ++ $root.NodeLocationMetadata.encode(message.location, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); ++ if (message.extra != null && Object.hasOwnProperty.call(message, "extra")) ++ writer.uint32(/* id 3, wireType 2 =*/26).string(message.extra); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified DistributionBucketOperatorMetadata message, length delimited. Does not implicitly {@link DistributionBucketOperatorMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof DistributionBucketOperatorMetadata ++ * @static ++ * @param {IDistributionBucketOperatorMetadata} message DistributionBucketOperatorMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ DistributionBucketOperatorMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a DistributionBucketOperatorMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof DistributionBucketOperatorMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {DistributionBucketOperatorMetadata} DistributionBucketOperatorMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ DistributionBucketOperatorMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.DistributionBucketOperatorMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.endpoint = reader.string(); ++ break; ++ case 2: ++ message.location = $root.NodeLocationMetadata.decode(reader, reader.uint32()); ++ break; ++ case 3: ++ message.extra = reader.string(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a DistributionBucketOperatorMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof DistributionBucketOperatorMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {DistributionBucketOperatorMetadata} DistributionBucketOperatorMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ DistributionBucketOperatorMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a DistributionBucketOperatorMetadata message. ++ * @function verify ++ * @memberof DistributionBucketOperatorMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ DistributionBucketOperatorMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.endpoint != null && message.hasOwnProperty("endpoint")) ++ if (!$util.isString(message.endpoint)) ++ return "endpoint: string expected"; ++ if (message.location != null && message.hasOwnProperty("location")) { ++ var error = $root.NodeLocationMetadata.verify(message.location); ++ if (error) ++ return "location." + error; ++ } ++ if (message.extra != null && message.hasOwnProperty("extra")) ++ if (!$util.isString(message.extra)) ++ return "extra: string expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a DistributionBucketOperatorMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof DistributionBucketOperatorMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {DistributionBucketOperatorMetadata} DistributionBucketOperatorMetadata ++ */ ++ DistributionBucketOperatorMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.DistributionBucketOperatorMetadata) ++ return object; ++ var message = new $root.DistributionBucketOperatorMetadata(); ++ if (object.endpoint != null) ++ message.endpoint = String(object.endpoint); ++ if (object.location != null) { ++ if (typeof object.location !== "object") ++ throw TypeError(".DistributionBucketOperatorMetadata.location: object expected"); ++ message.location = $root.NodeLocationMetadata.fromObject(object.location); ++ } ++ if (object.extra != null) ++ message.extra = String(object.extra); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a DistributionBucketOperatorMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof DistributionBucketOperatorMetadata ++ * @static ++ * @param {DistributionBucketOperatorMetadata} message DistributionBucketOperatorMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ DistributionBucketOperatorMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.endpoint = ""; ++ object.location = null; ++ object.extra = ""; ++ } ++ if (message.endpoint != null && message.hasOwnProperty("endpoint")) ++ object.endpoint = message.endpoint; ++ if (message.location != null && message.hasOwnProperty("location")) ++ object.location = $root.NodeLocationMetadata.toObject(message.location, options); ++ if (message.extra != null && message.hasOwnProperty("extra")) ++ object.extra = message.extra; ++ return object; ++ }; ++ ++ /** ++ * Converts this DistributionBucketOperatorMetadata to JSON. ++ * @function toJSON ++ * @memberof DistributionBucketOperatorMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ DistributionBucketOperatorMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return DistributionBucketOperatorMetadata; ++})(); ++ ++$root.GeographicalArea = (function() { ++ ++ /** ++ * Properties of a GeographicalArea. ++ * @exports IGeographicalArea ++ * @interface IGeographicalArea ++ * @property {GeographicalArea.Continent|null} [continent] GeographicalArea continent ++ * @property {string|null} [countryCode] GeographicalArea countryCode ++ * @property {string|null} [subdivisionCode] GeographicalArea subdivisionCode ++ */ ++ ++ /** ++ * Constructs a new GeographicalArea. ++ * @exports GeographicalArea ++ * @classdesc Represents a GeographicalArea. ++ * @implements IGeographicalArea ++ * @constructor ++ * @param {IGeographicalArea=} [properties] Properties to set ++ */ ++ function GeographicalArea(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * GeographicalArea continent. ++ * @member {GeographicalArea.Continent|null|undefined} continent ++ * @memberof GeographicalArea ++ * @instance ++ */ ++ GeographicalArea.prototype.continent = null; ++ ++ /** ++ * GeographicalArea countryCode. ++ * @member {string|null|undefined} countryCode ++ * @memberof GeographicalArea ++ * @instance ++ */ ++ GeographicalArea.prototype.countryCode = null; ++ ++ /** ++ * GeographicalArea subdivisionCode. ++ * @member {string|null|undefined} subdivisionCode ++ * @memberof GeographicalArea ++ * @instance ++ */ ++ GeographicalArea.prototype.subdivisionCode = null; ++ ++ // OneOf field names bound to virtual getters and setters ++ var $oneOfFields; ++ ++ /** ++ * GeographicalArea code. ++ * @member {"continent"|"countryCode"|"subdivisionCode"|undefined} code ++ * @memberof GeographicalArea ++ * @instance ++ */ ++ Object.defineProperty(GeographicalArea.prototype, "code", { ++ get: $util.oneOfGetter($oneOfFields = ["continent", "countryCode", "subdivisionCode"]), ++ set: $util.oneOfSetter($oneOfFields) ++ }); ++ ++ /** ++ * Creates a new GeographicalArea instance using the specified properties. ++ * @function create ++ * @memberof GeographicalArea ++ * @static ++ * @param {IGeographicalArea=} [properties] Properties to set ++ * @returns {GeographicalArea} GeographicalArea instance ++ */ ++ GeographicalArea.create = function create(properties) { ++ return new GeographicalArea(properties); ++ }; ++ ++ /** ++ * Encodes the specified GeographicalArea message. Does not implicitly {@link GeographicalArea.verify|verify} messages. ++ * @function encode ++ * @memberof GeographicalArea ++ * @static ++ * @param {IGeographicalArea} message GeographicalArea message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ GeographicalArea.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.continent != null && Object.hasOwnProperty.call(message, "continent")) ++ writer.uint32(/* id 1, wireType 0 =*/8).int32(message.continent); ++ if (message.countryCode != null && Object.hasOwnProperty.call(message, "countryCode")) ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.countryCode); ++ if (message.subdivisionCode != null && Object.hasOwnProperty.call(message, "subdivisionCode")) ++ writer.uint32(/* id 3, wireType 2 =*/26).string(message.subdivisionCode); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified GeographicalArea message, length delimited. Does not implicitly {@link GeographicalArea.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof GeographicalArea ++ * @static ++ * @param {IGeographicalArea} message GeographicalArea message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ GeographicalArea.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a GeographicalArea message from the specified reader or buffer. ++ * @function decode ++ * @memberof GeographicalArea ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {GeographicalArea} GeographicalArea ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ GeographicalArea.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.GeographicalArea(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.continent = reader.int32(); ++ break; ++ case 2: ++ message.countryCode = reader.string(); ++ break; ++ case 3: ++ message.subdivisionCode = reader.string(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a GeographicalArea message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof GeographicalArea ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {GeographicalArea} GeographicalArea ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ GeographicalArea.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a GeographicalArea message. ++ * @function verify ++ * @memberof GeographicalArea ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ GeographicalArea.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ var properties = {}; ++ if (message.continent != null && message.hasOwnProperty("continent")) { ++ properties.code = 1; ++ switch (message.continent) { ++ default: ++ return "continent: enum value expected"; ++ case 1: ++ case 2: ++ case 3: ++ case 4: ++ case 5: ++ case 6: ++ case 7: ++ break; ++ } ++ } ++ if (message.countryCode != null && message.hasOwnProperty("countryCode")) { ++ if (properties.code === 1) ++ return "code: multiple values"; ++ properties.code = 1; ++ if (!$util.isString(message.countryCode)) ++ return "countryCode: string expected"; ++ } ++ if (message.subdivisionCode != null && message.hasOwnProperty("subdivisionCode")) { ++ if (properties.code === 1) ++ return "code: multiple values"; ++ properties.code = 1; ++ if (!$util.isString(message.subdivisionCode)) ++ return "subdivisionCode: string expected"; ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates a GeographicalArea message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof GeographicalArea ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {GeographicalArea} GeographicalArea ++ */ ++ GeographicalArea.fromObject = function fromObject(object) { ++ if (object instanceof $root.GeographicalArea) ++ return object; ++ var message = new $root.GeographicalArea(); ++ switch (object.continent) { ++ case "AF": ++ case 1: ++ message.continent = 1; ++ break; ++ case "NA": ++ case 2: ++ message.continent = 2; ++ break; ++ case "OC": ++ case 3: ++ message.continent = 3; ++ break; ++ case "AN": ++ case 4: ++ message.continent = 4; ++ break; ++ case "AS": ++ case 5: ++ message.continent = 5; ++ break; ++ case "EU": ++ case 6: ++ message.continent = 6; ++ break; ++ case "SA": ++ case 7: ++ message.continent = 7; ++ break; ++ } ++ if (object.countryCode != null) ++ message.countryCode = String(object.countryCode); ++ if (object.subdivisionCode != null) ++ message.subdivisionCode = String(object.subdivisionCode); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a GeographicalArea message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof GeographicalArea ++ * @static ++ * @param {GeographicalArea} message GeographicalArea ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ GeographicalArea.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (message.continent != null && message.hasOwnProperty("continent")) { ++ object.continent = options.enums === String ? $root.GeographicalArea.Continent[message.continent] : message.continent; ++ if (options.oneofs) ++ object.code = "continent"; ++ } ++ if (message.countryCode != null && message.hasOwnProperty("countryCode")) { ++ object.countryCode = message.countryCode; ++ if (options.oneofs) ++ object.code = "countryCode"; ++ } ++ if (message.subdivisionCode != null && message.hasOwnProperty("subdivisionCode")) { ++ object.subdivisionCode = message.subdivisionCode; ++ if (options.oneofs) ++ object.code = "subdivisionCode"; ++ } ++ return object; ++ }; ++ ++ /** ++ * Converts this GeographicalArea to JSON. ++ * @function toJSON ++ * @memberof GeographicalArea ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ GeographicalArea.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ /** ++ * Continent enum. ++ * @name GeographicalArea.Continent ++ * @enum {number} ++ * @property {number} AF=1 AF value ++ * @property {number} NA=2 NA value ++ * @property {number} OC=3 OC value ++ * @property {number} AN=4 AN value ++ * @property {number} AS=5 AS value ++ * @property {number} EU=6 EU value ++ * @property {number} SA=7 SA value ++ */ ++ GeographicalArea.Continent = (function() { ++ var valuesById = {}, values = Object.create(valuesById); ++ values[valuesById[1] = "AF"] = 1; ++ values[valuesById[2] = "NA"] = 2; ++ values[valuesById[3] = "OC"] = 3; ++ values[valuesById[4] = "AN"] = 4; ++ values[valuesById[5] = "AS"] = 5; ++ values[valuesById[6] = "EU"] = 6; ++ values[valuesById[7] = "SA"] = 7; ++ return values; ++ })(); ++ ++ return GeographicalArea; ++})(); ++ ++$root.DistributionBucketFamilyMetadata = (function() { ++ ++ /** ++ * Properties of a DistributionBucketFamilyMetadata. ++ * @exports IDistributionBucketFamilyMetadata ++ * @interface IDistributionBucketFamilyMetadata ++ * @property {string|null} [region] DistributionBucketFamilyMetadata region ++ * @property {string|null} [description] DistributionBucketFamilyMetadata description ++ * @property {Array.|null} [areas] DistributionBucketFamilyMetadata areas ++ * @property {Array.|null} [latencyTestTargets] DistributionBucketFamilyMetadata latencyTestTargets ++ */ ++ ++ /** ++ * Constructs a new DistributionBucketFamilyMetadata. ++ * @exports DistributionBucketFamilyMetadata ++ * @classdesc Represents a DistributionBucketFamilyMetadata. ++ * @implements IDistributionBucketFamilyMetadata ++ * @constructor ++ * @param {IDistributionBucketFamilyMetadata=} [properties] Properties to set ++ */ ++ function DistributionBucketFamilyMetadata(properties) { ++ this.areas = []; ++ this.latencyTestTargets = []; ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * DistributionBucketFamilyMetadata region. ++ * @member {string} region ++ * @memberof DistributionBucketFamilyMetadata ++ * @instance ++ */ ++ DistributionBucketFamilyMetadata.prototype.region = ""; ++ ++ /** ++ * DistributionBucketFamilyMetadata description. ++ * @member {string} description ++ * @memberof DistributionBucketFamilyMetadata ++ * @instance ++ */ ++ DistributionBucketFamilyMetadata.prototype.description = ""; ++ ++ /** ++ * DistributionBucketFamilyMetadata areas. ++ * @member {Array.} areas ++ * @memberof DistributionBucketFamilyMetadata ++ * @instance ++ */ ++ DistributionBucketFamilyMetadata.prototype.areas = $util.emptyArray; ++ ++ /** ++ * DistributionBucketFamilyMetadata latencyTestTargets. ++ * @member {Array.} latencyTestTargets ++ * @memberof DistributionBucketFamilyMetadata ++ * @instance ++ */ ++ DistributionBucketFamilyMetadata.prototype.latencyTestTargets = $util.emptyArray; ++ ++ /** ++ * Creates a new DistributionBucketFamilyMetadata instance using the specified properties. ++ * @function create ++ * @memberof DistributionBucketFamilyMetadata ++ * @static ++ * @param {IDistributionBucketFamilyMetadata=} [properties] Properties to set ++ * @returns {DistributionBucketFamilyMetadata} DistributionBucketFamilyMetadata instance ++ */ ++ DistributionBucketFamilyMetadata.create = function create(properties) { ++ return new DistributionBucketFamilyMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified DistributionBucketFamilyMetadata message. Does not implicitly {@link DistributionBucketFamilyMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof DistributionBucketFamilyMetadata ++ * @static ++ * @param {IDistributionBucketFamilyMetadata} message DistributionBucketFamilyMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ DistributionBucketFamilyMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.region != null && Object.hasOwnProperty.call(message, "region")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.region); ++ if (message.description != null && Object.hasOwnProperty.call(message, "description")) ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.description); ++ if (message.areas != null && message.areas.length) ++ for (var i = 0; i < message.areas.length; ++i) ++ $root.GeographicalArea.encode(message.areas[i], writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim(); ++ if (message.latencyTestTargets != null && message.latencyTestTargets.length) ++ for (var i = 0; i < message.latencyTestTargets.length; ++i) ++ writer.uint32(/* id 4, wireType 2 =*/34).string(message.latencyTestTargets[i]); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified DistributionBucketFamilyMetadata message, length delimited. Does not implicitly {@link DistributionBucketFamilyMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof DistributionBucketFamilyMetadata ++ * @static ++ * @param {IDistributionBucketFamilyMetadata} message DistributionBucketFamilyMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ DistributionBucketFamilyMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a DistributionBucketFamilyMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof DistributionBucketFamilyMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {DistributionBucketFamilyMetadata} DistributionBucketFamilyMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ DistributionBucketFamilyMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.DistributionBucketFamilyMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.region = reader.string(); ++ break; ++ case 2: ++ message.description = reader.string(); ++ break; ++ case 3: ++ if (!(message.areas && message.areas.length)) ++ message.areas = []; ++ message.areas.push($root.GeographicalArea.decode(reader, reader.uint32())); ++ break; ++ case 4: ++ if (!(message.latencyTestTargets && message.latencyTestTargets.length)) ++ message.latencyTestTargets = []; ++ message.latencyTestTargets.push(reader.string()); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a DistributionBucketFamilyMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof DistributionBucketFamilyMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {DistributionBucketFamilyMetadata} DistributionBucketFamilyMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ DistributionBucketFamilyMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a DistributionBucketFamilyMetadata message. ++ * @function verify ++ * @memberof DistributionBucketFamilyMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ DistributionBucketFamilyMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.region != null && message.hasOwnProperty("region")) ++ if (!$util.isString(message.region)) ++ return "region: string expected"; ++ if (message.description != null && message.hasOwnProperty("description")) ++ if (!$util.isString(message.description)) ++ return "description: string expected"; ++ if (message.areas != null && message.hasOwnProperty("areas")) { ++ if (!Array.isArray(message.areas)) ++ return "areas: array expected"; ++ for (var i = 0; i < message.areas.length; ++i) { ++ var error = $root.GeographicalArea.verify(message.areas[i]); ++ if (error) ++ return "areas." + error; ++ } ++ } ++ if (message.latencyTestTargets != null && message.hasOwnProperty("latencyTestTargets")) { ++ if (!Array.isArray(message.latencyTestTargets)) ++ return "latencyTestTargets: array expected"; ++ for (var i = 0; i < message.latencyTestTargets.length; ++i) ++ if (!$util.isString(message.latencyTestTargets[i])) ++ return "latencyTestTargets: string[] expected"; ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates a DistributionBucketFamilyMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof DistributionBucketFamilyMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {DistributionBucketFamilyMetadata} DistributionBucketFamilyMetadata ++ */ ++ DistributionBucketFamilyMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.DistributionBucketFamilyMetadata) ++ return object; ++ var message = new $root.DistributionBucketFamilyMetadata(); ++ if (object.region != null) ++ message.region = String(object.region); ++ if (object.description != null) ++ message.description = String(object.description); ++ if (object.areas) { ++ if (!Array.isArray(object.areas)) ++ throw TypeError(".DistributionBucketFamilyMetadata.areas: array expected"); ++ message.areas = []; ++ for (var i = 0; i < object.areas.length; ++i) { ++ if (typeof object.areas[i] !== "object") ++ throw TypeError(".DistributionBucketFamilyMetadata.areas: object expected"); ++ message.areas[i] = $root.GeographicalArea.fromObject(object.areas[i]); ++ } ++ } ++ if (object.latencyTestTargets) { ++ if (!Array.isArray(object.latencyTestTargets)) ++ throw TypeError(".DistributionBucketFamilyMetadata.latencyTestTargets: array expected"); ++ message.latencyTestTargets = []; ++ for (var i = 0; i < object.latencyTestTargets.length; ++i) ++ message.latencyTestTargets[i] = String(object.latencyTestTargets[i]); ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a DistributionBucketFamilyMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof DistributionBucketFamilyMetadata ++ * @static ++ * @param {DistributionBucketFamilyMetadata} message DistributionBucketFamilyMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ DistributionBucketFamilyMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.arrays || options.defaults) { ++ object.areas = []; ++ object.latencyTestTargets = []; ++ } ++ if (options.defaults) { ++ object.region = ""; ++ object.description = ""; ++ } ++ if (message.region != null && message.hasOwnProperty("region")) ++ object.region = message.region; ++ if (message.description != null && message.hasOwnProperty("description")) ++ object.description = message.description; ++ if (message.areas && message.areas.length) { ++ object.areas = []; ++ for (var j = 0; j < message.areas.length; ++j) ++ object.areas[j] = $root.GeographicalArea.toObject(message.areas[j], options); ++ } ++ if (message.latencyTestTargets && message.latencyTestTargets.length) { ++ object.latencyTestTargets = []; ++ for (var j = 0; j < message.latencyTestTargets.length; ++j) ++ object.latencyTestTargets[j] = message.latencyTestTargets[j]; ++ } ++ return object; ++ }; ++ ++ /** ++ * Converts this DistributionBucketFamilyMetadata to JSON. ++ * @function toJSON ++ * @memberof DistributionBucketFamilyMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ DistributionBucketFamilyMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return DistributionBucketFamilyMetadata; ++})(); ++ ++$root.CreatorTokenIssuerRemarked = (function() { ++ ++ /** ++ * Properties of a CreatorTokenIssuerRemarked. ++ * @exports ICreatorTokenIssuerRemarked ++ * @interface ICreatorTokenIssuerRemarked ++ * @property {IUpdateTokenMetadata|null} [updateTokenMetadata] CreatorTokenIssuerRemarked updateTokenMetadata ++ */ ++ ++ /** ++ * Constructs a new CreatorTokenIssuerRemarked. ++ * @exports CreatorTokenIssuerRemarked ++ * @classdesc Represents a CreatorTokenIssuerRemarked. ++ * @implements ICreatorTokenIssuerRemarked ++ * @constructor ++ * @param {ICreatorTokenIssuerRemarked=} [properties] Properties to set ++ */ ++ function CreatorTokenIssuerRemarked(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * CreatorTokenIssuerRemarked updateTokenMetadata. ++ * @member {IUpdateTokenMetadata|null|undefined} updateTokenMetadata ++ * @memberof CreatorTokenIssuerRemarked ++ * @instance ++ */ ++ CreatorTokenIssuerRemarked.prototype.updateTokenMetadata = null; ++ ++ // OneOf field names bound to virtual getters and setters ++ var $oneOfFields; ++ ++ /** ++ * CreatorTokenIssuerRemarked creatorTokenIssuerRemarked. ++ * @member {"updateTokenMetadata"|undefined} creatorTokenIssuerRemarked ++ * @memberof CreatorTokenIssuerRemarked ++ * @instance ++ */ ++ Object.defineProperty(CreatorTokenIssuerRemarked.prototype, "creatorTokenIssuerRemarked", { ++ get: $util.oneOfGetter($oneOfFields = ["updateTokenMetadata"]), ++ set: $util.oneOfSetter($oneOfFields) ++ }); ++ ++ /** ++ * Creates a new CreatorTokenIssuerRemarked instance using the specified properties. ++ * @function create ++ * @memberof CreatorTokenIssuerRemarked ++ * @static ++ * @param {ICreatorTokenIssuerRemarked=} [properties] Properties to set ++ * @returns {CreatorTokenIssuerRemarked} CreatorTokenIssuerRemarked instance ++ */ ++ CreatorTokenIssuerRemarked.create = function create(properties) { ++ return new CreatorTokenIssuerRemarked(properties); ++ }; ++ ++ /** ++ * Encodes the specified CreatorTokenIssuerRemarked message. Does not implicitly {@link CreatorTokenIssuerRemarked.verify|verify} messages. ++ * @function encode ++ * @memberof CreatorTokenIssuerRemarked ++ * @static ++ * @param {ICreatorTokenIssuerRemarked} message CreatorTokenIssuerRemarked message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ CreatorTokenIssuerRemarked.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.updateTokenMetadata != null && Object.hasOwnProperty.call(message, "updateTokenMetadata")) ++ $root.UpdateTokenMetadata.encode(message.updateTokenMetadata, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified CreatorTokenIssuerRemarked message, length delimited. Does not implicitly {@link CreatorTokenIssuerRemarked.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof CreatorTokenIssuerRemarked ++ * @static ++ * @param {ICreatorTokenIssuerRemarked} message CreatorTokenIssuerRemarked message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ CreatorTokenIssuerRemarked.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a CreatorTokenIssuerRemarked message from the specified reader or buffer. ++ * @function decode ++ * @memberof CreatorTokenIssuerRemarked ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {CreatorTokenIssuerRemarked} CreatorTokenIssuerRemarked ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ CreatorTokenIssuerRemarked.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.CreatorTokenIssuerRemarked(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.updateTokenMetadata = $root.UpdateTokenMetadata.decode(reader, reader.uint32()); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a CreatorTokenIssuerRemarked message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof CreatorTokenIssuerRemarked ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {CreatorTokenIssuerRemarked} CreatorTokenIssuerRemarked ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ CreatorTokenIssuerRemarked.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a CreatorTokenIssuerRemarked message. ++ * @function verify ++ * @memberof CreatorTokenIssuerRemarked ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ CreatorTokenIssuerRemarked.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ var properties = {}; ++ if (message.updateTokenMetadata != null && message.hasOwnProperty("updateTokenMetadata")) { ++ properties.creatorTokenIssuerRemarked = 1; ++ { ++ var error = $root.UpdateTokenMetadata.verify(message.updateTokenMetadata); ++ if (error) ++ return "updateTokenMetadata." + error; ++ } ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates a CreatorTokenIssuerRemarked message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof CreatorTokenIssuerRemarked ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {CreatorTokenIssuerRemarked} CreatorTokenIssuerRemarked ++ */ ++ CreatorTokenIssuerRemarked.fromObject = function fromObject(object) { ++ if (object instanceof $root.CreatorTokenIssuerRemarked) ++ return object; ++ var message = new $root.CreatorTokenIssuerRemarked(); ++ if (object.updateTokenMetadata != null) { ++ if (typeof object.updateTokenMetadata !== "object") ++ throw TypeError(".CreatorTokenIssuerRemarked.updateTokenMetadata: object expected"); ++ message.updateTokenMetadata = $root.UpdateTokenMetadata.fromObject(object.updateTokenMetadata); ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a CreatorTokenIssuerRemarked message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof CreatorTokenIssuerRemarked ++ * @static ++ * @param {CreatorTokenIssuerRemarked} message CreatorTokenIssuerRemarked ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ CreatorTokenIssuerRemarked.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (message.updateTokenMetadata != null && message.hasOwnProperty("updateTokenMetadata")) { ++ object.updateTokenMetadata = $root.UpdateTokenMetadata.toObject(message.updateTokenMetadata, options); ++ if (options.oneofs) ++ object.creatorTokenIssuerRemarked = "updateTokenMetadata"; ++ } ++ return object; ++ }; ++ ++ /** ++ * Converts this CreatorTokenIssuerRemarked to JSON. ++ * @function toJSON ++ * @memberof CreatorTokenIssuerRemarked ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ CreatorTokenIssuerRemarked.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return CreatorTokenIssuerRemarked; ++})(); ++ ++$root.UpdateTokenMetadata = (function() { ++ ++ /** ++ * Properties of an UpdateTokenMetadata. ++ * @exports IUpdateTokenMetadata ++ * @interface IUpdateTokenMetadata ++ * @property {ITokenMetadata|null} [newMetadata] UpdateTokenMetadata newMetadata ++ */ ++ ++ /** ++ * Constructs a new UpdateTokenMetadata. ++ * @exports UpdateTokenMetadata ++ * @classdesc Represents an UpdateTokenMetadata. ++ * @implements IUpdateTokenMetadata ++ * @constructor ++ * @param {IUpdateTokenMetadata=} [properties] Properties to set ++ */ ++ function UpdateTokenMetadata(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * UpdateTokenMetadata newMetadata. ++ * @member {ITokenMetadata|null|undefined} newMetadata ++ * @memberof UpdateTokenMetadata ++ * @instance ++ */ ++ UpdateTokenMetadata.prototype.newMetadata = null; ++ ++ /** ++ * Creates a new UpdateTokenMetadata instance using the specified properties. ++ * @function create ++ * @memberof UpdateTokenMetadata ++ * @static ++ * @param {IUpdateTokenMetadata=} [properties] Properties to set ++ * @returns {UpdateTokenMetadata} UpdateTokenMetadata instance ++ */ ++ UpdateTokenMetadata.create = function create(properties) { ++ return new UpdateTokenMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified UpdateTokenMetadata message. Does not implicitly {@link UpdateTokenMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof UpdateTokenMetadata ++ * @static ++ * @param {IUpdateTokenMetadata} message UpdateTokenMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ UpdateTokenMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.newMetadata != null && Object.hasOwnProperty.call(message, "newMetadata")) ++ $root.TokenMetadata.encode(message.newMetadata, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified UpdateTokenMetadata message, length delimited. Does not implicitly {@link UpdateTokenMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof UpdateTokenMetadata ++ * @static ++ * @param {IUpdateTokenMetadata} message UpdateTokenMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ UpdateTokenMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes an UpdateTokenMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof UpdateTokenMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {UpdateTokenMetadata} UpdateTokenMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ UpdateTokenMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.UpdateTokenMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.newMetadata = $root.TokenMetadata.decode(reader, reader.uint32()); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes an UpdateTokenMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof UpdateTokenMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {UpdateTokenMetadata} UpdateTokenMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ UpdateTokenMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies an UpdateTokenMetadata message. ++ * @function verify ++ * @memberof UpdateTokenMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ UpdateTokenMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.newMetadata != null && message.hasOwnProperty("newMetadata")) { ++ var error = $root.TokenMetadata.verify(message.newMetadata); ++ if (error) ++ return "newMetadata." + error; ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates an UpdateTokenMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof UpdateTokenMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {UpdateTokenMetadata} UpdateTokenMetadata ++ */ ++ UpdateTokenMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.UpdateTokenMetadata) ++ return object; ++ var message = new $root.UpdateTokenMetadata(); ++ if (object.newMetadata != null) { ++ if (typeof object.newMetadata !== "object") ++ throw TypeError(".UpdateTokenMetadata.newMetadata: object expected"); ++ message.newMetadata = $root.TokenMetadata.fromObject(object.newMetadata); ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from an UpdateTokenMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof UpdateTokenMetadata ++ * @static ++ * @param {UpdateTokenMetadata} message UpdateTokenMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ UpdateTokenMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) ++ object.newMetadata = null; ++ if (message.newMetadata != null && message.hasOwnProperty("newMetadata")) ++ object.newMetadata = $root.TokenMetadata.toObject(message.newMetadata, options); ++ return object; ++ }; ++ ++ /** ++ * Converts this UpdateTokenMetadata to JSON. ++ * @function toJSON ++ * @memberof UpdateTokenMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ UpdateTokenMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return UpdateTokenMetadata; ++})(); ++ ++$root.TokenMetadata = (function() { ++ ++ /** ++ * Properties of a TokenMetadata. ++ * @exports ITokenMetadata ++ * @interface ITokenMetadata ++ * @property {string|null} [name] TokenMetadata name ++ * @property {string} symbol TokenMetadata symbol ++ * @property {string|null} [description] TokenMetadata description ++ * @property {number|null} [avatarObject] TokenMetadata avatarObject ++ * @property {string|null} [avatarUri] TokenMetadata avatarUri ++ * @property {Array.|null} [benefits] TokenMetadata benefits ++ * @property {string|null} [whitelistApplicationNote] TokenMetadata whitelistApplicationNote ++ * @property {string|null} [whitelistApplicationApplyLink] TokenMetadata whitelistApplicationApplyLink ++ * @property {Long|null} [trailerVideoId] TokenMetadata trailerVideoId ++ */ ++ ++ /** ++ * Constructs a new TokenMetadata. ++ * @exports TokenMetadata ++ * @classdesc Represents a TokenMetadata. ++ * @implements ITokenMetadata ++ * @constructor ++ * @param {ITokenMetadata=} [properties] Properties to set ++ */ ++ function TokenMetadata(properties) { ++ this.benefits = []; ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * TokenMetadata name. ++ * @member {string} name ++ * @memberof TokenMetadata ++ * @instance ++ */ ++ TokenMetadata.prototype.name = ""; ++ ++ /** ++ * TokenMetadata symbol. ++ * @member {string} symbol ++ * @memberof TokenMetadata ++ * @instance ++ */ ++ TokenMetadata.prototype.symbol = ""; ++ ++ /** ++ * TokenMetadata description. ++ * @member {string} description ++ * @memberof TokenMetadata ++ * @instance ++ */ ++ TokenMetadata.prototype.description = ""; ++ ++ /** ++ * TokenMetadata avatarObject. ++ * @member {number|null|undefined} avatarObject ++ * @memberof TokenMetadata ++ * @instance ++ */ ++ TokenMetadata.prototype.avatarObject = null; ++ ++ /** ++ * TokenMetadata avatarUri. ++ * @member {string|null|undefined} avatarUri ++ * @memberof TokenMetadata ++ * @instance ++ */ ++ TokenMetadata.prototype.avatarUri = null; ++ ++ /** ++ * TokenMetadata benefits. ++ * @member {Array.} benefits ++ * @memberof TokenMetadata ++ * @instance ++ */ ++ TokenMetadata.prototype.benefits = $util.emptyArray; ++ ++ /** ++ * TokenMetadata whitelistApplicationNote. ++ * @member {string} whitelistApplicationNote ++ * @memberof TokenMetadata ++ * @instance ++ */ ++ TokenMetadata.prototype.whitelistApplicationNote = ""; ++ ++ /** ++ * TokenMetadata whitelistApplicationApplyLink. ++ * @member {string} whitelistApplicationApplyLink ++ * @memberof TokenMetadata ++ * @instance ++ */ ++ TokenMetadata.prototype.whitelistApplicationApplyLink = ""; ++ ++ /** ++ * TokenMetadata trailerVideoId. ++ * @member {Long} trailerVideoId ++ * @memberof TokenMetadata ++ * @instance ++ */ ++ TokenMetadata.prototype.trailerVideoId = $util.Long ? $util.Long.fromBits(0,0,true) : 0; ++ ++ // OneOf field names bound to virtual getters and setters ++ var $oneOfFields; ++ ++ /** ++ * TokenMetadata avatar. ++ * @member {"avatarObject"|"avatarUri"|undefined} avatar ++ * @memberof TokenMetadata ++ * @instance ++ */ ++ Object.defineProperty(TokenMetadata.prototype, "avatar", { ++ get: $util.oneOfGetter($oneOfFields = ["avatarObject", "avatarUri"]), ++ set: $util.oneOfSetter($oneOfFields) ++ }); ++ ++ /** ++ * Creates a new TokenMetadata instance using the specified properties. ++ * @function create ++ * @memberof TokenMetadata ++ * @static ++ * @param {ITokenMetadata=} [properties] Properties to set ++ * @returns {TokenMetadata} TokenMetadata instance ++ */ ++ TokenMetadata.create = function create(properties) { ++ return new TokenMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified TokenMetadata message. Does not implicitly {@link TokenMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof TokenMetadata ++ * @static ++ * @param {ITokenMetadata} message TokenMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ TokenMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.name != null && Object.hasOwnProperty.call(message, "name")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.name); ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.symbol); ++ if (message.description != null && Object.hasOwnProperty.call(message, "description")) ++ writer.uint32(/* id 3, wireType 2 =*/26).string(message.description); ++ if (message.avatarObject != null && Object.hasOwnProperty.call(message, "avatarObject")) ++ writer.uint32(/* id 4, wireType 0 =*/32).uint32(message.avatarObject); ++ if (message.avatarUri != null && Object.hasOwnProperty.call(message, "avatarUri")) ++ writer.uint32(/* id 5, wireType 2 =*/42).string(message.avatarUri); ++ if (message.benefits != null && message.benefits.length) ++ for (var i = 0; i < message.benefits.length; ++i) ++ $root.Benefit.encode(message.benefits[i], writer.uint32(/* id 6, wireType 2 =*/50).fork()).ldelim(); ++ if (message.whitelistApplicationNote != null && Object.hasOwnProperty.call(message, "whitelistApplicationNote")) ++ writer.uint32(/* id 7, wireType 2 =*/58).string(message.whitelistApplicationNote); ++ if (message.whitelistApplicationApplyLink != null && Object.hasOwnProperty.call(message, "whitelistApplicationApplyLink")) ++ writer.uint32(/* id 8, wireType 2 =*/66).string(message.whitelistApplicationApplyLink); ++ if (message.trailerVideoId != null && Object.hasOwnProperty.call(message, "trailerVideoId")) ++ writer.uint32(/* id 9, wireType 0 =*/72).uint64(message.trailerVideoId); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified TokenMetadata message, length delimited. Does not implicitly {@link TokenMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof TokenMetadata ++ * @static ++ * @param {ITokenMetadata} message TokenMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ TokenMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a TokenMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof TokenMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {TokenMetadata} TokenMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ TokenMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.TokenMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.name = reader.string(); ++ break; ++ case 2: ++ message.symbol = reader.string(); ++ break; ++ case 3: ++ message.description = reader.string(); ++ break; ++ case 4: ++ message.avatarObject = reader.uint32(); ++ break; ++ case 5: ++ message.avatarUri = reader.string(); ++ break; ++ case 6: ++ if (!(message.benefits && message.benefits.length)) ++ message.benefits = []; ++ message.benefits.push($root.Benefit.decode(reader, reader.uint32())); ++ break; ++ case 7: ++ message.whitelistApplicationNote = reader.string(); ++ break; ++ case 8: ++ message.whitelistApplicationApplyLink = reader.string(); ++ break; ++ case 9: ++ message.trailerVideoId = reader.uint64(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ if (!message.hasOwnProperty("symbol")) ++ throw $util.ProtocolError("missing required 'symbol'", { instance: message }); ++ return message; ++ }; ++ ++ /** ++ * Decodes a TokenMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof TokenMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {TokenMetadata} TokenMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ TokenMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a TokenMetadata message. ++ * @function verify ++ * @memberof TokenMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ TokenMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ var properties = {}; ++ if (message.name != null && message.hasOwnProperty("name")) ++ if (!$util.isString(message.name)) ++ return "name: string expected"; ++ if (!$util.isString(message.symbol)) ++ return "symbol: string expected"; ++ if (message.description != null && message.hasOwnProperty("description")) ++ if (!$util.isString(message.description)) ++ return "description: string expected"; ++ if (message.avatarObject != null && message.hasOwnProperty("avatarObject")) { ++ properties.avatar = 1; ++ if (!$util.isInteger(message.avatarObject)) ++ return "avatarObject: integer expected"; ++ } ++ if (message.avatarUri != null && message.hasOwnProperty("avatarUri")) { ++ if (properties.avatar === 1) ++ return "avatar: multiple values"; ++ properties.avatar = 1; ++ if (!$util.isString(message.avatarUri)) ++ return "avatarUri: string expected"; ++ } ++ if (message.benefits != null && message.hasOwnProperty("benefits")) { ++ if (!Array.isArray(message.benefits)) ++ return "benefits: array expected"; ++ for (var i = 0; i < message.benefits.length; ++i) { ++ var error = $root.Benefit.verify(message.benefits[i]); ++ if (error) ++ return "benefits." + error; ++ } ++ } ++ if (message.whitelistApplicationNote != null && message.hasOwnProperty("whitelistApplicationNote")) ++ if (!$util.isString(message.whitelistApplicationNote)) ++ return "whitelistApplicationNote: string expected"; ++ if (message.whitelistApplicationApplyLink != null && message.hasOwnProperty("whitelistApplicationApplyLink")) ++ if (!$util.isString(message.whitelistApplicationApplyLink)) ++ return "whitelistApplicationApplyLink: string expected"; ++ if (message.trailerVideoId != null && message.hasOwnProperty("trailerVideoId")) ++ if (!$util.isInteger(message.trailerVideoId) && !(message.trailerVideoId && $util.isInteger(message.trailerVideoId.low) && $util.isInteger(message.trailerVideoId.high))) ++ return "trailerVideoId: integer|Long expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a TokenMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof TokenMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {TokenMetadata} TokenMetadata ++ */ ++ TokenMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.TokenMetadata) ++ return object; ++ var message = new $root.TokenMetadata(); ++ if (object.name != null) ++ message.name = String(object.name); ++ if (object.symbol != null) ++ message.symbol = String(object.symbol); ++ if (object.description != null) ++ message.description = String(object.description); ++ if (object.avatarObject != null) ++ message.avatarObject = object.avatarObject >>> 0; ++ if (object.avatarUri != null) ++ message.avatarUri = String(object.avatarUri); ++ if (object.benefits) { ++ if (!Array.isArray(object.benefits)) ++ throw TypeError(".TokenMetadata.benefits: array expected"); ++ message.benefits = []; ++ for (var i = 0; i < object.benefits.length; ++i) { ++ if (typeof object.benefits[i] !== "object") ++ throw TypeError(".TokenMetadata.benefits: object expected"); ++ message.benefits[i] = $root.Benefit.fromObject(object.benefits[i]); ++ } ++ } ++ if (object.whitelistApplicationNote != null) ++ message.whitelistApplicationNote = String(object.whitelistApplicationNote); ++ if (object.whitelistApplicationApplyLink != null) ++ message.whitelistApplicationApplyLink = String(object.whitelistApplicationApplyLink); ++ if (object.trailerVideoId != null) ++ if ($util.Long) ++ (message.trailerVideoId = $util.Long.fromValue(object.trailerVideoId)).unsigned = true; ++ else if (typeof object.trailerVideoId === "string") ++ message.trailerVideoId = parseInt(object.trailerVideoId, 10); ++ else if (typeof object.trailerVideoId === "number") ++ message.trailerVideoId = object.trailerVideoId; ++ else if (typeof object.trailerVideoId === "object") ++ message.trailerVideoId = new $util.LongBits(object.trailerVideoId.low >>> 0, object.trailerVideoId.high >>> 0).toNumber(true); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a TokenMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof TokenMetadata ++ * @static ++ * @param {TokenMetadata} message TokenMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ TokenMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.arrays || options.defaults) ++ object.benefits = []; ++ if (options.defaults) { ++ object.name = ""; ++ object.symbol = ""; ++ object.description = ""; ++ object.whitelistApplicationNote = ""; ++ object.whitelistApplicationApplyLink = ""; ++ if ($util.Long) { ++ var long = new $util.Long(0, 0, true); ++ object.trailerVideoId = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; ++ } else ++ object.trailerVideoId = options.longs === String ? "0" : 0; ++ } ++ if (message.name != null && message.hasOwnProperty("name")) ++ object.name = message.name; ++ if (message.symbol != null && message.hasOwnProperty("symbol")) ++ object.symbol = message.symbol; ++ if (message.description != null && message.hasOwnProperty("description")) ++ object.description = message.description; ++ if (message.avatarObject != null && message.hasOwnProperty("avatarObject")) { ++ object.avatarObject = message.avatarObject; ++ if (options.oneofs) ++ object.avatar = "avatarObject"; ++ } ++ if (message.avatarUri != null && message.hasOwnProperty("avatarUri")) { ++ object.avatarUri = message.avatarUri; ++ if (options.oneofs) ++ object.avatar = "avatarUri"; ++ } ++ if (message.benefits && message.benefits.length) { ++ object.benefits = []; ++ for (var j = 0; j < message.benefits.length; ++j) ++ object.benefits[j] = $root.Benefit.toObject(message.benefits[j], options); ++ } ++ if (message.whitelistApplicationNote != null && message.hasOwnProperty("whitelistApplicationNote")) ++ object.whitelistApplicationNote = message.whitelistApplicationNote; ++ if (message.whitelistApplicationApplyLink != null && message.hasOwnProperty("whitelistApplicationApplyLink")) ++ object.whitelistApplicationApplyLink = message.whitelistApplicationApplyLink; ++ if (message.trailerVideoId != null && message.hasOwnProperty("trailerVideoId")) ++ if (typeof message.trailerVideoId === "number") ++ object.trailerVideoId = options.longs === String ? String(message.trailerVideoId) : message.trailerVideoId; ++ else ++ object.trailerVideoId = options.longs === String ? $util.Long.prototype.toString.call(message.trailerVideoId) : options.longs === Number ? new $util.LongBits(message.trailerVideoId.low >>> 0, message.trailerVideoId.high >>> 0).toNumber(true) : message.trailerVideoId; ++ return object; ++ }; ++ ++ /** ++ * Converts this TokenMetadata to JSON. ++ * @function toJSON ++ * @memberof TokenMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ TokenMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return TokenMetadata; ++})(); ++ ++$root.Benefit = (function() { ++ ++ /** ++ * Properties of a Benefit. ++ * @exports IBenefit ++ * @interface IBenefit ++ * @property {string|null} [title] Benefit title ++ * @property {string|null} [description] Benefit description ++ * @property {string|null} [emoji] Benefit emoji ++ * @property {number|null} [displayOrder] Benefit displayOrder ++ */ ++ ++ /** ++ * Constructs a new Benefit. ++ * @exports Benefit ++ * @classdesc Represents a Benefit. ++ * @implements IBenefit ++ * @constructor ++ * @param {IBenefit=} [properties] Properties to set ++ */ ++ function Benefit(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * Benefit title. ++ * @member {string} title ++ * @memberof Benefit ++ * @instance ++ */ ++ Benefit.prototype.title = ""; ++ ++ /** ++ * Benefit description. ++ * @member {string} description ++ * @memberof Benefit ++ * @instance ++ */ ++ Benefit.prototype.description = ""; ++ ++ /** ++ * Benefit emoji. ++ * @member {string} emoji ++ * @memberof Benefit ++ * @instance ++ */ ++ Benefit.prototype.emoji = ""; ++ ++ /** ++ * Benefit displayOrder. ++ * @member {number} displayOrder ++ * @memberof Benefit ++ * @instance ++ */ ++ Benefit.prototype.displayOrder = 0; ++ ++ /** ++ * Creates a new Benefit instance using the specified properties. ++ * @function create ++ * @memberof Benefit ++ * @static ++ * @param {IBenefit=} [properties] Properties to set ++ * @returns {Benefit} Benefit instance ++ */ ++ Benefit.create = function create(properties) { ++ return new Benefit(properties); ++ }; ++ ++ /** ++ * Encodes the specified Benefit message. Does not implicitly {@link Benefit.verify|verify} messages. ++ * @function encode ++ * @memberof Benefit ++ * @static ++ * @param {IBenefit} message Benefit message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ Benefit.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.title != null && Object.hasOwnProperty.call(message, "title")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.title); ++ if (message.description != null && Object.hasOwnProperty.call(message, "description")) ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.description); ++ if (message.emoji != null && Object.hasOwnProperty.call(message, "emoji")) ++ writer.uint32(/* id 3, wireType 2 =*/26).string(message.emoji); ++ if (message.displayOrder != null && Object.hasOwnProperty.call(message, "displayOrder")) ++ writer.uint32(/* id 4, wireType 0 =*/32).uint32(message.displayOrder); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified Benefit message, length delimited. Does not implicitly {@link Benefit.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof Benefit ++ * @static ++ * @param {IBenefit} message Benefit message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ Benefit.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a Benefit message from the specified reader or buffer. ++ * @function decode ++ * @memberof Benefit ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {Benefit} Benefit ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ Benefit.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.Benefit(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.title = reader.string(); ++ break; ++ case 2: ++ message.description = reader.string(); ++ break; ++ case 3: ++ message.emoji = reader.string(); ++ break; ++ case 4: ++ message.displayOrder = reader.uint32(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a Benefit message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof Benefit ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {Benefit} Benefit ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ Benefit.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a Benefit message. ++ * @function verify ++ * @memberof Benefit ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ Benefit.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.title != null && message.hasOwnProperty("title")) ++ if (!$util.isString(message.title)) ++ return "title: string expected"; ++ if (message.description != null && message.hasOwnProperty("description")) ++ if (!$util.isString(message.description)) ++ return "description: string expected"; ++ if (message.emoji != null && message.hasOwnProperty("emoji")) ++ if (!$util.isString(message.emoji)) ++ return "emoji: string expected"; ++ if (message.displayOrder != null && message.hasOwnProperty("displayOrder")) ++ if (!$util.isInteger(message.displayOrder)) ++ return "displayOrder: integer expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a Benefit message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof Benefit ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {Benefit} Benefit ++ */ ++ Benefit.fromObject = function fromObject(object) { ++ if (object instanceof $root.Benefit) ++ return object; ++ var message = new $root.Benefit(); ++ if (object.title != null) ++ message.title = String(object.title); ++ if (object.description != null) ++ message.description = String(object.description); ++ if (object.emoji != null) ++ message.emoji = String(object.emoji); ++ if (object.displayOrder != null) ++ message.displayOrder = object.displayOrder >>> 0; ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a Benefit message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof Benefit ++ * @static ++ * @param {Benefit} message Benefit ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ Benefit.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.title = ""; ++ object.description = ""; ++ object.emoji = ""; ++ object.displayOrder = 0; ++ } ++ if (message.title != null && message.hasOwnProperty("title")) ++ object.title = message.title; ++ if (message.description != null && message.hasOwnProperty("description")) ++ object.description = message.description; ++ if (message.emoji != null && message.hasOwnProperty("emoji")) ++ object.emoji = message.emoji; ++ if (message.displayOrder != null && message.hasOwnProperty("displayOrder")) ++ object.displayOrder = message.displayOrder; ++ return object; ++ }; ++ ++ /** ++ * Converts this Benefit to JSON. ++ * @function toJSON ++ * @memberof Benefit ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ Benefit.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return Benefit; ++})(); ++ ++$root.SaleMetadata = (function() { ++ ++ /** ++ * Properties of a SaleMetadata. ++ * @exports ISaleMetadata ++ * @interface ISaleMetadata ++ * @property {string|null} [termsAndConditions] SaleMetadata termsAndConditions ++ */ ++ ++ /** ++ * Constructs a new SaleMetadata. ++ * @exports SaleMetadata ++ * @classdesc Represents a SaleMetadata. ++ * @implements ISaleMetadata ++ * @constructor ++ * @param {ISaleMetadata=} [properties] Properties to set ++ */ ++ function SaleMetadata(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * SaleMetadata termsAndConditions. ++ * @member {string} termsAndConditions ++ * @memberof SaleMetadata ++ * @instance ++ */ ++ SaleMetadata.prototype.termsAndConditions = ""; ++ ++ /** ++ * Creates a new SaleMetadata instance using the specified properties. ++ * @function create ++ * @memberof SaleMetadata ++ * @static ++ * @param {ISaleMetadata=} [properties] Properties to set ++ * @returns {SaleMetadata} SaleMetadata instance ++ */ ++ SaleMetadata.create = function create(properties) { ++ return new SaleMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified SaleMetadata message. Does not implicitly {@link SaleMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof SaleMetadata ++ * @static ++ * @param {ISaleMetadata} message SaleMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ SaleMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.termsAndConditions != null && Object.hasOwnProperty.call(message, "termsAndConditions")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.termsAndConditions); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified SaleMetadata message, length delimited. Does not implicitly {@link SaleMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof SaleMetadata ++ * @static ++ * @param {ISaleMetadata} message SaleMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ SaleMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a SaleMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof SaleMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {SaleMetadata} SaleMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ SaleMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.SaleMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.termsAndConditions = reader.string(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a SaleMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof SaleMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {SaleMetadata} SaleMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ SaleMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a SaleMetadata message. ++ * @function verify ++ * @memberof SaleMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ SaleMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.termsAndConditions != null && message.hasOwnProperty("termsAndConditions")) ++ if (!$util.isString(message.termsAndConditions)) ++ return "termsAndConditions: string expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a SaleMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof SaleMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {SaleMetadata} SaleMetadata ++ */ ++ SaleMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.SaleMetadata) ++ return object; ++ var message = new $root.SaleMetadata(); ++ if (object.termsAndConditions != null) ++ message.termsAndConditions = String(object.termsAndConditions); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a SaleMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof SaleMetadata ++ * @static ++ * @param {SaleMetadata} message SaleMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ SaleMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) ++ object.termsAndConditions = ""; ++ if (message.termsAndConditions != null && message.hasOwnProperty("termsAndConditions")) ++ object.termsAndConditions = message.termsAndConditions; ++ return object; ++ }; ++ ++ /** ++ * Converts this SaleMetadata to JSON. ++ * @function toJSON ++ * @memberof SaleMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ SaleMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return SaleMetadata; ++})(); ++ ++$root.PublishedBeforeJoystream = (function() { ++ ++ /** ++ * Properties of a PublishedBeforeJoystream. ++ * @exports IPublishedBeforeJoystream ++ * @interface IPublishedBeforeJoystream ++ * @property {boolean|null} [isPublished] PublishedBeforeJoystream isPublished ++ * @property {string|null} [date] PublishedBeforeJoystream date ++ */ ++ ++ /** ++ * Constructs a new PublishedBeforeJoystream. ++ * @exports PublishedBeforeJoystream ++ * @classdesc Represents a PublishedBeforeJoystream. ++ * @implements IPublishedBeforeJoystream ++ * @constructor ++ * @param {IPublishedBeforeJoystream=} [properties] Properties to set ++ */ ++ function PublishedBeforeJoystream(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * PublishedBeforeJoystream isPublished. ++ * @member {boolean} isPublished ++ * @memberof PublishedBeforeJoystream ++ * @instance ++ */ ++ PublishedBeforeJoystream.prototype.isPublished = false; ++ ++ /** ++ * PublishedBeforeJoystream date. ++ * @member {string} date ++ * @memberof PublishedBeforeJoystream ++ * @instance ++ */ ++ PublishedBeforeJoystream.prototype.date = ""; ++ ++ /** ++ * Creates a new PublishedBeforeJoystream instance using the specified properties. ++ * @function create ++ * @memberof PublishedBeforeJoystream ++ * @static ++ * @param {IPublishedBeforeJoystream=} [properties] Properties to set ++ * @returns {PublishedBeforeJoystream} PublishedBeforeJoystream instance ++ */ ++ PublishedBeforeJoystream.create = function create(properties) { ++ return new PublishedBeforeJoystream(properties); ++ }; ++ ++ /** ++ * Encodes the specified PublishedBeforeJoystream message. Does not implicitly {@link PublishedBeforeJoystream.verify|verify} messages. ++ * @function encode ++ * @memberof PublishedBeforeJoystream ++ * @static ++ * @param {IPublishedBeforeJoystream} message PublishedBeforeJoystream message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ PublishedBeforeJoystream.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.isPublished != null && Object.hasOwnProperty.call(message, "isPublished")) ++ writer.uint32(/* id 1, wireType 0 =*/8).bool(message.isPublished); ++ if (message.date != null && Object.hasOwnProperty.call(message, "date")) ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.date); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified PublishedBeforeJoystream message, length delimited. Does not implicitly {@link PublishedBeforeJoystream.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof PublishedBeforeJoystream ++ * @static ++ * @param {IPublishedBeforeJoystream} message PublishedBeforeJoystream message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ PublishedBeforeJoystream.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a PublishedBeforeJoystream message from the specified reader or buffer. ++ * @function decode ++ * @memberof PublishedBeforeJoystream ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {PublishedBeforeJoystream} PublishedBeforeJoystream ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ PublishedBeforeJoystream.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.PublishedBeforeJoystream(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.isPublished = reader.bool(); ++ break; ++ case 2: ++ message.date = reader.string(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a PublishedBeforeJoystream message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof PublishedBeforeJoystream ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {PublishedBeforeJoystream} PublishedBeforeJoystream ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ PublishedBeforeJoystream.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a PublishedBeforeJoystream message. ++ * @function verify ++ * @memberof PublishedBeforeJoystream ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ PublishedBeforeJoystream.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.isPublished != null && message.hasOwnProperty("isPublished")) ++ if (typeof message.isPublished !== "boolean") ++ return "isPublished: boolean expected"; ++ if (message.date != null && message.hasOwnProperty("date")) ++ if (!$util.isString(message.date)) ++ return "date: string expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a PublishedBeforeJoystream message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof PublishedBeforeJoystream ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {PublishedBeforeJoystream} PublishedBeforeJoystream ++ */ ++ PublishedBeforeJoystream.fromObject = function fromObject(object) { ++ if (object instanceof $root.PublishedBeforeJoystream) ++ return object; ++ var message = new $root.PublishedBeforeJoystream(); ++ if (object.isPublished != null) ++ message.isPublished = Boolean(object.isPublished); ++ if (object.date != null) ++ message.date = String(object.date); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a PublishedBeforeJoystream message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof PublishedBeforeJoystream ++ * @static ++ * @param {PublishedBeforeJoystream} message PublishedBeforeJoystream ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ PublishedBeforeJoystream.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.isPublished = false; ++ object.date = ""; ++ } ++ if (message.isPublished != null && message.hasOwnProperty("isPublished")) ++ object.isPublished = message.isPublished; ++ if (message.date != null && message.hasOwnProperty("date")) ++ object.date = message.date; ++ return object; ++ }; ++ ++ /** ++ * Converts this PublishedBeforeJoystream to JSON. ++ * @function toJSON ++ * @memberof PublishedBeforeJoystream ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ PublishedBeforeJoystream.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return PublishedBeforeJoystream; ++})(); ++ ++$root.License = (function() { ++ ++ /** ++ * Properties of a License. ++ * @exports ILicense ++ * @interface ILicense ++ * @property {number|null} [code] License code ++ * @property {string|null} [attribution] License attribution ++ * @property {string|null} [customText] License customText ++ */ ++ ++ /** ++ * Constructs a new License. ++ * @exports License ++ * @classdesc Represents a License. ++ * @implements ILicense ++ * @constructor ++ * @param {ILicense=} [properties] Properties to set ++ */ ++ function License(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * License code. ++ * @member {number} code ++ * @memberof License ++ * @instance ++ */ ++ License.prototype.code = 0; ++ ++ /** ++ * License attribution. ++ * @member {string} attribution ++ * @memberof License ++ * @instance ++ */ ++ License.prototype.attribution = ""; ++ ++ /** ++ * License customText. ++ * @member {string} customText ++ * @memberof License ++ * @instance ++ */ ++ License.prototype.customText = ""; ++ ++ /** ++ * Creates a new License instance using the specified properties. ++ * @function create ++ * @memberof License ++ * @static ++ * @param {ILicense=} [properties] Properties to set ++ * @returns {License} License instance ++ */ ++ License.create = function create(properties) { ++ return new License(properties); ++ }; ++ ++ /** ++ * Encodes the specified License message. Does not implicitly {@link License.verify|verify} messages. ++ * @function encode ++ * @memberof License ++ * @static ++ * @param {ILicense} message License message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ License.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.code != null && Object.hasOwnProperty.call(message, "code")) ++ writer.uint32(/* id 1, wireType 0 =*/8).uint32(message.code); ++ if (message.attribution != null && Object.hasOwnProperty.call(message, "attribution")) ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.attribution); ++ if (message.customText != null && Object.hasOwnProperty.call(message, "customText")) ++ writer.uint32(/* id 3, wireType 2 =*/26).string(message.customText); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified License message, length delimited. Does not implicitly {@link License.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof License ++ * @static ++ * @param {ILicense} message License message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ License.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a License message from the specified reader or buffer. ++ * @function decode ++ * @memberof License ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {License} License ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ License.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.License(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.code = reader.uint32(); ++ break; ++ case 2: ++ message.attribution = reader.string(); ++ break; ++ case 3: ++ message.customText = reader.string(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a License message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof License ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {License} License ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ License.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a License message. ++ * @function verify ++ * @memberof License ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ License.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.code != null && message.hasOwnProperty("code")) ++ if (!$util.isInteger(message.code)) ++ return "code: integer expected"; ++ if (message.attribution != null && message.hasOwnProperty("attribution")) ++ if (!$util.isString(message.attribution)) ++ return "attribution: string expected"; ++ if (message.customText != null && message.hasOwnProperty("customText")) ++ if (!$util.isString(message.customText)) ++ return "customText: string expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a License message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof License ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {License} License ++ */ ++ License.fromObject = function fromObject(object) { ++ if (object instanceof $root.License) ++ return object; ++ var message = new $root.License(); ++ if (object.code != null) ++ message.code = object.code >>> 0; ++ if (object.attribution != null) ++ message.attribution = String(object.attribution); ++ if (object.customText != null) ++ message.customText = String(object.customText); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a License message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof License ++ * @static ++ * @param {License} message License ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ License.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.code = 0; ++ object.attribution = ""; ++ object.customText = ""; ++ } ++ if (message.code != null && message.hasOwnProperty("code")) ++ object.code = message.code; ++ if (message.attribution != null && message.hasOwnProperty("attribution")) ++ object.attribution = message.attribution; ++ if (message.customText != null && message.hasOwnProperty("customText")) ++ object.customText = message.customText; ++ return object; ++ }; ++ ++ /** ++ * Converts this License to JSON. ++ * @function toJSON ++ * @memberof License ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ License.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return License; ++})(); ++ ++$root.MediaType = (function() { ++ ++ /** ++ * Properties of a MediaType. ++ * @exports IMediaType ++ * @interface IMediaType ++ * @property {string|null} [codecName] MediaType codecName ++ * @property {string|null} [container] MediaType container ++ * @property {string|null} [mimeMediaType] MediaType mimeMediaType ++ */ ++ ++ /** ++ * Constructs a new MediaType. ++ * @exports MediaType ++ * @classdesc Represents a MediaType. ++ * @implements IMediaType ++ * @constructor ++ * @param {IMediaType=} [properties] Properties to set ++ */ ++ function MediaType(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * MediaType codecName. ++ * @member {string} codecName ++ * @memberof MediaType ++ * @instance ++ */ ++ MediaType.prototype.codecName = ""; ++ ++ /** ++ * MediaType container. ++ * @member {string} container ++ * @memberof MediaType ++ * @instance ++ */ ++ MediaType.prototype.container = ""; ++ ++ /** ++ * MediaType mimeMediaType. ++ * @member {string} mimeMediaType ++ * @memberof MediaType ++ * @instance ++ */ ++ MediaType.prototype.mimeMediaType = ""; ++ ++ /** ++ * Creates a new MediaType instance using the specified properties. ++ * @function create ++ * @memberof MediaType ++ * @static ++ * @param {IMediaType=} [properties] Properties to set ++ * @returns {MediaType} MediaType instance ++ */ ++ MediaType.create = function create(properties) { ++ return new MediaType(properties); ++ }; ++ ++ /** ++ * Encodes the specified MediaType message. Does not implicitly {@link MediaType.verify|verify} messages. ++ * @function encode ++ * @memberof MediaType ++ * @static ++ * @param {IMediaType} message MediaType message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ MediaType.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.codecName != null && Object.hasOwnProperty.call(message, "codecName")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.codecName); ++ if (message.container != null && Object.hasOwnProperty.call(message, "container")) ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.container); ++ if (message.mimeMediaType != null && Object.hasOwnProperty.call(message, "mimeMediaType")) ++ writer.uint32(/* id 3, wireType 2 =*/26).string(message.mimeMediaType); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified MediaType message, length delimited. Does not implicitly {@link MediaType.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof MediaType ++ * @static ++ * @param {IMediaType} message MediaType message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ MediaType.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a MediaType message from the specified reader or buffer. ++ * @function decode ++ * @memberof MediaType ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {MediaType} MediaType ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ MediaType.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.MediaType(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.codecName = reader.string(); ++ break; ++ case 2: ++ message.container = reader.string(); ++ break; ++ case 3: ++ message.mimeMediaType = reader.string(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a MediaType message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof MediaType ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {MediaType} MediaType ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ MediaType.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a MediaType message. ++ * @function verify ++ * @memberof MediaType ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ MediaType.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.codecName != null && message.hasOwnProperty("codecName")) ++ if (!$util.isString(message.codecName)) ++ return "codecName: string expected"; ++ if (message.container != null && message.hasOwnProperty("container")) ++ if (!$util.isString(message.container)) ++ return "container: string expected"; ++ if (message.mimeMediaType != null && message.hasOwnProperty("mimeMediaType")) ++ if (!$util.isString(message.mimeMediaType)) ++ return "mimeMediaType: string expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a MediaType message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof MediaType ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {MediaType} MediaType ++ */ ++ MediaType.fromObject = function fromObject(object) { ++ if (object instanceof $root.MediaType) ++ return object; ++ var message = new $root.MediaType(); ++ if (object.codecName != null) ++ message.codecName = String(object.codecName); ++ if (object.container != null) ++ message.container = String(object.container); ++ if (object.mimeMediaType != null) ++ message.mimeMediaType = String(object.mimeMediaType); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a MediaType message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof MediaType ++ * @static ++ * @param {MediaType} message MediaType ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ MediaType.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.codecName = ""; ++ object.container = ""; ++ object.mimeMediaType = ""; ++ } ++ if (message.codecName != null && message.hasOwnProperty("codecName")) ++ object.codecName = message.codecName; ++ if (message.container != null && message.hasOwnProperty("container")) ++ object.container = message.container; ++ if (message.mimeMediaType != null && message.hasOwnProperty("mimeMediaType")) ++ object.mimeMediaType = message.mimeMediaType; ++ return object; ++ }; ++ ++ /** ++ * Converts this MediaType to JSON. ++ * @function toJSON ++ * @memberof MediaType ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ MediaType.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return MediaType; ++})(); ++ ++$root.SubtitleMetadata = (function() { ++ ++ /** ++ * Properties of a SubtitleMetadata. ++ * @exports ISubtitleMetadata ++ * @interface ISubtitleMetadata ++ * @property {string} type SubtitleMetadata type ++ * @property {number|null} [newAsset] SubtitleMetadata newAsset ++ * @property {string} language SubtitleMetadata language ++ * @property {string} mimeType SubtitleMetadata mimeType ++ */ ++ ++ /** ++ * Constructs a new SubtitleMetadata. ++ * @exports SubtitleMetadata ++ * @classdesc Represents a SubtitleMetadata. ++ * @implements ISubtitleMetadata ++ * @constructor ++ * @param {ISubtitleMetadata=} [properties] Properties to set ++ */ ++ function SubtitleMetadata(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * SubtitleMetadata type. ++ * @member {string} type ++ * @memberof SubtitleMetadata ++ * @instance ++ */ ++ SubtitleMetadata.prototype.type = ""; ++ ++ /** ++ * SubtitleMetadata newAsset. ++ * @member {number} newAsset ++ * @memberof SubtitleMetadata ++ * @instance ++ */ ++ SubtitleMetadata.prototype.newAsset = 0; ++ ++ /** ++ * SubtitleMetadata language. ++ * @member {string} language ++ * @memberof SubtitleMetadata ++ * @instance ++ */ ++ SubtitleMetadata.prototype.language = ""; ++ ++ /** ++ * SubtitleMetadata mimeType. ++ * @member {string} mimeType ++ * @memberof SubtitleMetadata ++ * @instance ++ */ ++ SubtitleMetadata.prototype.mimeType = ""; ++ ++ /** ++ * Creates a new SubtitleMetadata instance using the specified properties. ++ * @function create ++ * @memberof SubtitleMetadata ++ * @static ++ * @param {ISubtitleMetadata=} [properties] Properties to set ++ * @returns {SubtitleMetadata} SubtitleMetadata instance ++ */ ++ SubtitleMetadata.create = function create(properties) { ++ return new SubtitleMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified SubtitleMetadata message. Does not implicitly {@link SubtitleMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof SubtitleMetadata ++ * @static ++ * @param {ISubtitleMetadata} message SubtitleMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ SubtitleMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.type); ++ if (message.newAsset != null && Object.hasOwnProperty.call(message, "newAsset")) ++ writer.uint32(/* id 2, wireType 0 =*/16).uint32(message.newAsset); ++ writer.uint32(/* id 3, wireType 2 =*/26).string(message.language); ++ writer.uint32(/* id 4, wireType 2 =*/34).string(message.mimeType); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified SubtitleMetadata message, length delimited. Does not implicitly {@link SubtitleMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof SubtitleMetadata ++ * @static ++ * @param {ISubtitleMetadata} message SubtitleMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ SubtitleMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a SubtitleMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof SubtitleMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {SubtitleMetadata} SubtitleMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ SubtitleMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.SubtitleMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.type = reader.string(); ++ break; ++ case 2: ++ message.newAsset = reader.uint32(); ++ break; ++ case 3: ++ message.language = reader.string(); ++ break; ++ case 4: ++ message.mimeType = reader.string(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ if (!message.hasOwnProperty("type")) ++ throw $util.ProtocolError("missing required 'type'", { instance: message }); ++ if (!message.hasOwnProperty("language")) ++ throw $util.ProtocolError("missing required 'language'", { instance: message }); ++ if (!message.hasOwnProperty("mimeType")) ++ throw $util.ProtocolError("missing required 'mimeType'", { instance: message }); ++ return message; ++ }; ++ ++ /** ++ * Decodes a SubtitleMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof SubtitleMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {SubtitleMetadata} SubtitleMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ SubtitleMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a SubtitleMetadata message. ++ * @function verify ++ * @memberof SubtitleMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ SubtitleMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (!$util.isString(message.type)) ++ return "type: string expected"; ++ if (message.newAsset != null && message.hasOwnProperty("newAsset")) ++ if (!$util.isInteger(message.newAsset)) ++ return "newAsset: integer expected"; ++ if (!$util.isString(message.language)) ++ return "language: string expected"; ++ if (!$util.isString(message.mimeType)) ++ return "mimeType: string expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a SubtitleMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof SubtitleMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {SubtitleMetadata} SubtitleMetadata ++ */ ++ SubtitleMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.SubtitleMetadata) ++ return object; ++ var message = new $root.SubtitleMetadata(); ++ if (object.type != null) ++ message.type = String(object.type); ++ if (object.newAsset != null) ++ message.newAsset = object.newAsset >>> 0; ++ if (object.language != null) ++ message.language = String(object.language); ++ if (object.mimeType != null) ++ message.mimeType = String(object.mimeType); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a SubtitleMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof SubtitleMetadata ++ * @static ++ * @param {SubtitleMetadata} message SubtitleMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ SubtitleMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.type = ""; ++ object.newAsset = 0; ++ object.language = ""; ++ object.mimeType = ""; ++ } ++ if (message.type != null && message.hasOwnProperty("type")) ++ object.type = message.type; ++ if (message.newAsset != null && message.hasOwnProperty("newAsset")) ++ object.newAsset = message.newAsset; ++ if (message.language != null && message.hasOwnProperty("language")) ++ object.language = message.language; ++ if (message.mimeType != null && message.hasOwnProperty("mimeType")) ++ object.mimeType = message.mimeType; ++ return object; ++ }; ++ ++ /** ++ * Converts this SubtitleMetadata to JSON. ++ * @function toJSON ++ * @memberof SubtitleMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ SubtitleMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return SubtitleMetadata; ++})(); ++ ++$root.VideoMetadata = (function() { ++ ++ /** ++ * Properties of a VideoMetadata. ++ * @exports IVideoMetadata ++ * @interface IVideoMetadata ++ * @property {string|null} [title] VideoMetadata title ++ * @property {string|null} [description] VideoMetadata description ++ * @property {number|null} [video] VideoMetadata video ++ * @property {number|null} [thumbnailPhoto] VideoMetadata thumbnailPhoto ++ * @property {number|null} [duration] VideoMetadata duration ++ * @property {number|null} [mediaPixelHeight] VideoMetadata mediaPixelHeight ++ * @property {number|null} [mediaPixelWidth] VideoMetadata mediaPixelWidth ++ * @property {IMediaType|null} [mediaType] VideoMetadata mediaType ++ * @property {string|null} [language] VideoMetadata language ++ * @property {ILicense|null} [license] VideoMetadata license ++ * @property {IPublishedBeforeJoystream|null} [publishedBeforeJoystream] VideoMetadata publishedBeforeJoystream ++ * @property {boolean|null} [hasMarketing] VideoMetadata hasMarketing ++ * @property {boolean|null} [isPublic] VideoMetadata isPublic ++ * @property {boolean|null} [isExplicit] VideoMetadata isExplicit ++ * @property {Array.|null} [persons] VideoMetadata persons ++ * @property {string|null} [category] VideoMetadata category ++ * @property {Array.|null} [subtitles] VideoMetadata subtitles ++ * @property {boolean|null} [enableComments] VideoMetadata enableComments ++ * @property {boolean|null} [clearSubtitles] VideoMetadata clearSubtitles ++ */ ++ ++ /** ++ * Constructs a new VideoMetadata. ++ * @exports VideoMetadata ++ * @classdesc Represents a VideoMetadata. ++ * @implements IVideoMetadata ++ * @constructor ++ * @param {IVideoMetadata=} [properties] Properties to set ++ */ ++ function VideoMetadata(properties) { ++ this.persons = []; ++ this.subtitles = []; ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * VideoMetadata title. ++ * @member {string} title ++ * @memberof VideoMetadata ++ * @instance ++ */ ++ VideoMetadata.prototype.title = ""; ++ ++ /** ++ * VideoMetadata description. ++ * @member {string} description ++ * @memberof VideoMetadata ++ * @instance ++ */ ++ VideoMetadata.prototype.description = ""; ++ ++ /** ++ * VideoMetadata video. ++ * @member {number} video ++ * @memberof VideoMetadata ++ * @instance ++ */ ++ VideoMetadata.prototype.video = 0; ++ ++ /** ++ * VideoMetadata thumbnailPhoto. ++ * @member {number} thumbnailPhoto ++ * @memberof VideoMetadata ++ * @instance ++ */ ++ VideoMetadata.prototype.thumbnailPhoto = 0; ++ ++ /** ++ * VideoMetadata duration. ++ * @member {number} duration ++ * @memberof VideoMetadata ++ * @instance ++ */ ++ VideoMetadata.prototype.duration = 0; ++ ++ /** ++ * VideoMetadata mediaPixelHeight. ++ * @member {number} mediaPixelHeight ++ * @memberof VideoMetadata ++ * @instance ++ */ ++ VideoMetadata.prototype.mediaPixelHeight = 0; ++ ++ /** ++ * VideoMetadata mediaPixelWidth. ++ * @member {number} mediaPixelWidth ++ * @memberof VideoMetadata ++ * @instance ++ */ ++ VideoMetadata.prototype.mediaPixelWidth = 0; ++ ++ /** ++ * VideoMetadata mediaType. ++ * @member {IMediaType|null|undefined} mediaType ++ * @memberof VideoMetadata ++ * @instance ++ */ ++ VideoMetadata.prototype.mediaType = null; ++ ++ /** ++ * VideoMetadata language. ++ * @member {string} language ++ * @memberof VideoMetadata ++ * @instance ++ */ ++ VideoMetadata.prototype.language = ""; ++ ++ /** ++ * VideoMetadata license. ++ * @member {ILicense|null|undefined} license ++ * @memberof VideoMetadata ++ * @instance ++ */ ++ VideoMetadata.prototype.license = null; ++ ++ /** ++ * VideoMetadata publishedBeforeJoystream. ++ * @member {IPublishedBeforeJoystream|null|undefined} publishedBeforeJoystream ++ * @memberof VideoMetadata ++ * @instance ++ */ ++ VideoMetadata.prototype.publishedBeforeJoystream = null; ++ ++ /** ++ * VideoMetadata hasMarketing. ++ * @member {boolean} hasMarketing ++ * @memberof VideoMetadata ++ * @instance ++ */ ++ VideoMetadata.prototype.hasMarketing = false; ++ ++ /** ++ * VideoMetadata isPublic. ++ * @member {boolean} isPublic ++ * @memberof VideoMetadata ++ * @instance ++ */ ++ VideoMetadata.prototype.isPublic = false; ++ ++ /** ++ * VideoMetadata isExplicit. ++ * @member {boolean} isExplicit ++ * @memberof VideoMetadata ++ * @instance ++ */ ++ VideoMetadata.prototype.isExplicit = false; ++ ++ /** ++ * VideoMetadata persons. ++ * @member {Array.} persons ++ * @memberof VideoMetadata ++ * @instance ++ */ ++ VideoMetadata.prototype.persons = $util.emptyArray; ++ ++ /** ++ * VideoMetadata category. ++ * @member {string} category ++ * @memberof VideoMetadata ++ * @instance ++ */ ++ VideoMetadata.prototype.category = ""; ++ ++ /** ++ * VideoMetadata subtitles. ++ * @member {Array.} subtitles ++ * @memberof VideoMetadata ++ * @instance ++ */ ++ VideoMetadata.prototype.subtitles = $util.emptyArray; ++ ++ /** ++ * VideoMetadata enableComments. ++ * @member {boolean} enableComments ++ * @memberof VideoMetadata ++ * @instance ++ */ ++ VideoMetadata.prototype.enableComments = false; ++ ++ /** ++ * VideoMetadata clearSubtitles. ++ * @member {boolean} clearSubtitles ++ * @memberof VideoMetadata ++ * @instance ++ */ ++ VideoMetadata.prototype.clearSubtitles = false; ++ ++ /** ++ * Creates a new VideoMetadata instance using the specified properties. ++ * @function create ++ * @memberof VideoMetadata ++ * @static ++ * @param {IVideoMetadata=} [properties] Properties to set ++ * @returns {VideoMetadata} VideoMetadata instance ++ */ ++ VideoMetadata.create = function create(properties) { ++ return new VideoMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified VideoMetadata message. Does not implicitly {@link VideoMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof VideoMetadata ++ * @static ++ * @param {IVideoMetadata} message VideoMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ VideoMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.title != null && Object.hasOwnProperty.call(message, "title")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.title); ++ if (message.description != null && Object.hasOwnProperty.call(message, "description")) ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.description); ++ if (message.video != null && Object.hasOwnProperty.call(message, "video")) ++ writer.uint32(/* id 3, wireType 0 =*/24).uint32(message.video); ++ if (message.thumbnailPhoto != null && Object.hasOwnProperty.call(message, "thumbnailPhoto")) ++ writer.uint32(/* id 4, wireType 0 =*/32).uint32(message.thumbnailPhoto); ++ if (message.duration != null && Object.hasOwnProperty.call(message, "duration")) ++ writer.uint32(/* id 5, wireType 0 =*/40).uint32(message.duration); ++ if (message.mediaPixelHeight != null && Object.hasOwnProperty.call(message, "mediaPixelHeight")) ++ writer.uint32(/* id 6, wireType 0 =*/48).uint32(message.mediaPixelHeight); ++ if (message.mediaPixelWidth != null && Object.hasOwnProperty.call(message, "mediaPixelWidth")) ++ writer.uint32(/* id 7, wireType 0 =*/56).uint32(message.mediaPixelWidth); ++ if (message.mediaType != null && Object.hasOwnProperty.call(message, "mediaType")) ++ $root.MediaType.encode(message.mediaType, writer.uint32(/* id 8, wireType 2 =*/66).fork()).ldelim(); ++ if (message.language != null && Object.hasOwnProperty.call(message, "language")) ++ writer.uint32(/* id 9, wireType 2 =*/74).string(message.language); ++ if (message.license != null && Object.hasOwnProperty.call(message, "license")) ++ $root.License.encode(message.license, writer.uint32(/* id 10, wireType 2 =*/82).fork()).ldelim(); ++ if (message.publishedBeforeJoystream != null && Object.hasOwnProperty.call(message, "publishedBeforeJoystream")) ++ $root.PublishedBeforeJoystream.encode(message.publishedBeforeJoystream, writer.uint32(/* id 11, wireType 2 =*/90).fork()).ldelim(); ++ if (message.hasMarketing != null && Object.hasOwnProperty.call(message, "hasMarketing")) ++ writer.uint32(/* id 12, wireType 0 =*/96).bool(message.hasMarketing); ++ if (message.isPublic != null && Object.hasOwnProperty.call(message, "isPublic")) ++ writer.uint32(/* id 13, wireType 0 =*/104).bool(message.isPublic); ++ if (message.isExplicit != null && Object.hasOwnProperty.call(message, "isExplicit")) ++ writer.uint32(/* id 14, wireType 0 =*/112).bool(message.isExplicit); ++ if (message.persons != null && message.persons.length) { ++ writer.uint32(/* id 15, wireType 2 =*/122).fork(); ++ for (var i = 0; i < message.persons.length; ++i) ++ writer.uint64(message.persons[i]); ++ writer.ldelim(); ++ } ++ if (message.category != null && Object.hasOwnProperty.call(message, "category")) ++ writer.uint32(/* id 16, wireType 2 =*/130).string(message.category); ++ if (message.subtitles != null && message.subtitles.length) ++ for (var i = 0; i < message.subtitles.length; ++i) ++ $root.SubtitleMetadata.encode(message.subtitles[i], writer.uint32(/* id 17, wireType 2 =*/138).fork()).ldelim(); ++ if (message.enableComments != null && Object.hasOwnProperty.call(message, "enableComments")) ++ writer.uint32(/* id 18, wireType 0 =*/144).bool(message.enableComments); ++ if (message.clearSubtitles != null && Object.hasOwnProperty.call(message, "clearSubtitles")) ++ writer.uint32(/* id 19, wireType 0 =*/152).bool(message.clearSubtitles); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified VideoMetadata message, length delimited. Does not implicitly {@link VideoMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof VideoMetadata ++ * @static ++ * @param {IVideoMetadata} message VideoMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ VideoMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a VideoMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof VideoMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {VideoMetadata} VideoMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ VideoMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.VideoMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.title = reader.string(); ++ break; ++ case 2: ++ message.description = reader.string(); ++ break; ++ case 3: ++ message.video = reader.uint32(); ++ break; ++ case 4: ++ message.thumbnailPhoto = reader.uint32(); ++ break; ++ case 5: ++ message.duration = reader.uint32(); ++ break; ++ case 6: ++ message.mediaPixelHeight = reader.uint32(); ++ break; ++ case 7: ++ message.mediaPixelWidth = reader.uint32(); ++ break; ++ case 8: ++ message.mediaType = $root.MediaType.decode(reader, reader.uint32()); ++ break; ++ case 9: ++ message.language = reader.string(); ++ break; ++ case 10: ++ message.license = $root.License.decode(reader, reader.uint32()); ++ break; ++ case 11: ++ message.publishedBeforeJoystream = $root.PublishedBeforeJoystream.decode(reader, reader.uint32()); ++ break; ++ case 12: ++ message.hasMarketing = reader.bool(); ++ break; ++ case 13: ++ message.isPublic = reader.bool(); ++ break; ++ case 14: ++ message.isExplicit = reader.bool(); ++ break; ++ case 15: ++ if (!(message.persons && message.persons.length)) ++ message.persons = []; ++ if ((tag & 7) === 2) { ++ var end2 = reader.uint32() + reader.pos; ++ while (reader.pos < end2) ++ message.persons.push(reader.uint64()); ++ } else ++ message.persons.push(reader.uint64()); ++ break; ++ case 16: ++ message.category = reader.string(); ++ break; ++ case 17: ++ if (!(message.subtitles && message.subtitles.length)) ++ message.subtitles = []; ++ message.subtitles.push($root.SubtitleMetadata.decode(reader, reader.uint32())); ++ break; ++ case 18: ++ message.enableComments = reader.bool(); ++ break; ++ case 19: ++ message.clearSubtitles = reader.bool(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a VideoMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof VideoMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {VideoMetadata} VideoMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ VideoMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a VideoMetadata message. ++ * @function verify ++ * @memberof VideoMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ VideoMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.title != null && message.hasOwnProperty("title")) ++ if (!$util.isString(message.title)) ++ return "title: string expected"; ++ if (message.description != null && message.hasOwnProperty("description")) ++ if (!$util.isString(message.description)) ++ return "description: string expected"; ++ if (message.video != null && message.hasOwnProperty("video")) ++ if (!$util.isInteger(message.video)) ++ return "video: integer expected"; ++ if (message.thumbnailPhoto != null && message.hasOwnProperty("thumbnailPhoto")) ++ if (!$util.isInteger(message.thumbnailPhoto)) ++ return "thumbnailPhoto: integer expected"; ++ if (message.duration != null && message.hasOwnProperty("duration")) ++ if (!$util.isInteger(message.duration)) ++ return "duration: integer expected"; ++ if (message.mediaPixelHeight != null && message.hasOwnProperty("mediaPixelHeight")) ++ if (!$util.isInteger(message.mediaPixelHeight)) ++ return "mediaPixelHeight: integer expected"; ++ if (message.mediaPixelWidth != null && message.hasOwnProperty("mediaPixelWidth")) ++ if (!$util.isInteger(message.mediaPixelWidth)) ++ return "mediaPixelWidth: integer expected"; ++ if (message.mediaType != null && message.hasOwnProperty("mediaType")) { ++ var error = $root.MediaType.verify(message.mediaType); ++ if (error) ++ return "mediaType." + error; ++ } ++ if (message.language != null && message.hasOwnProperty("language")) ++ if (!$util.isString(message.language)) ++ return "language: string expected"; ++ if (message.license != null && message.hasOwnProperty("license")) { ++ var error = $root.License.verify(message.license); ++ if (error) ++ return "license." + error; ++ } ++ if (message.publishedBeforeJoystream != null && message.hasOwnProperty("publishedBeforeJoystream")) { ++ var error = $root.PublishedBeforeJoystream.verify(message.publishedBeforeJoystream); ++ if (error) ++ return "publishedBeforeJoystream." + error; ++ } ++ if (message.hasMarketing != null && message.hasOwnProperty("hasMarketing")) ++ if (typeof message.hasMarketing !== "boolean") ++ return "hasMarketing: boolean expected"; ++ if (message.isPublic != null && message.hasOwnProperty("isPublic")) ++ if (typeof message.isPublic !== "boolean") ++ return "isPublic: boolean expected"; ++ if (message.isExplicit != null && message.hasOwnProperty("isExplicit")) ++ if (typeof message.isExplicit !== "boolean") ++ return "isExplicit: boolean expected"; ++ if (message.persons != null && message.hasOwnProperty("persons")) { ++ if (!Array.isArray(message.persons)) ++ return "persons: array expected"; ++ for (var i = 0; i < message.persons.length; ++i) ++ if (!$util.isInteger(message.persons[i]) && !(message.persons[i] && $util.isInteger(message.persons[i].low) && $util.isInteger(message.persons[i].high))) ++ return "persons: integer|Long[] expected"; ++ } ++ if (message.category != null && message.hasOwnProperty("category")) ++ if (!$util.isString(message.category)) ++ return "category: string expected"; ++ if (message.subtitles != null && message.hasOwnProperty("subtitles")) { ++ if (!Array.isArray(message.subtitles)) ++ return "subtitles: array expected"; ++ for (var i = 0; i < message.subtitles.length; ++i) { ++ var error = $root.SubtitleMetadata.verify(message.subtitles[i]); ++ if (error) ++ return "subtitles." + error; ++ } ++ } ++ if (message.enableComments != null && message.hasOwnProperty("enableComments")) ++ if (typeof message.enableComments !== "boolean") ++ return "enableComments: boolean expected"; ++ if (message.clearSubtitles != null && message.hasOwnProperty("clearSubtitles")) ++ if (typeof message.clearSubtitles !== "boolean") ++ return "clearSubtitles: boolean expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a VideoMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof VideoMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {VideoMetadata} VideoMetadata ++ */ ++ VideoMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.VideoMetadata) ++ return object; ++ var message = new $root.VideoMetadata(); ++ if (object.title != null) ++ message.title = String(object.title); ++ if (object.description != null) ++ message.description = String(object.description); ++ if (object.video != null) ++ message.video = object.video >>> 0; ++ if (object.thumbnailPhoto != null) ++ message.thumbnailPhoto = object.thumbnailPhoto >>> 0; ++ if (object.duration != null) ++ message.duration = object.duration >>> 0; ++ if (object.mediaPixelHeight != null) ++ message.mediaPixelHeight = object.mediaPixelHeight >>> 0; ++ if (object.mediaPixelWidth != null) ++ message.mediaPixelWidth = object.mediaPixelWidth >>> 0; ++ if (object.mediaType != null) { ++ if (typeof object.mediaType !== "object") ++ throw TypeError(".VideoMetadata.mediaType: object expected"); ++ message.mediaType = $root.MediaType.fromObject(object.mediaType); ++ } ++ if (object.language != null) ++ message.language = String(object.language); ++ if (object.license != null) { ++ if (typeof object.license !== "object") ++ throw TypeError(".VideoMetadata.license: object expected"); ++ message.license = $root.License.fromObject(object.license); ++ } ++ if (object.publishedBeforeJoystream != null) { ++ if (typeof object.publishedBeforeJoystream !== "object") ++ throw TypeError(".VideoMetadata.publishedBeforeJoystream: object expected"); ++ message.publishedBeforeJoystream = $root.PublishedBeforeJoystream.fromObject(object.publishedBeforeJoystream); ++ } ++ if (object.hasMarketing != null) ++ message.hasMarketing = Boolean(object.hasMarketing); ++ if (object.isPublic != null) ++ message.isPublic = Boolean(object.isPublic); ++ if (object.isExplicit != null) ++ message.isExplicit = Boolean(object.isExplicit); ++ if (object.persons) { ++ if (!Array.isArray(object.persons)) ++ throw TypeError(".VideoMetadata.persons: array expected"); ++ message.persons = []; ++ for (var i = 0; i < object.persons.length; ++i) ++ if ($util.Long) ++ (message.persons[i] = $util.Long.fromValue(object.persons[i])).unsigned = true; ++ else if (typeof object.persons[i] === "string") ++ message.persons[i] = parseInt(object.persons[i], 10); ++ else if (typeof object.persons[i] === "number") ++ message.persons[i] = object.persons[i]; ++ else if (typeof object.persons[i] === "object") ++ message.persons[i] = new $util.LongBits(object.persons[i].low >>> 0, object.persons[i].high >>> 0).toNumber(true); ++ } ++ if (object.category != null) ++ message.category = String(object.category); ++ if (object.subtitles) { ++ if (!Array.isArray(object.subtitles)) ++ throw TypeError(".VideoMetadata.subtitles: array expected"); ++ message.subtitles = []; ++ for (var i = 0; i < object.subtitles.length; ++i) { ++ if (typeof object.subtitles[i] !== "object") ++ throw TypeError(".VideoMetadata.subtitles: object expected"); ++ message.subtitles[i] = $root.SubtitleMetadata.fromObject(object.subtitles[i]); ++ } ++ } ++ if (object.enableComments != null) ++ message.enableComments = Boolean(object.enableComments); ++ if (object.clearSubtitles != null) ++ message.clearSubtitles = Boolean(object.clearSubtitles); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a VideoMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof VideoMetadata ++ * @static ++ * @param {VideoMetadata} message VideoMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ VideoMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.arrays || options.defaults) { ++ object.persons = []; ++ object.subtitles = []; ++ } ++ if (options.defaults) { ++ object.title = ""; ++ object.description = ""; ++ object.video = 0; ++ object.thumbnailPhoto = 0; ++ object.duration = 0; ++ object.mediaPixelHeight = 0; ++ object.mediaPixelWidth = 0; ++ object.mediaType = null; ++ object.language = ""; ++ object.license = null; ++ object.publishedBeforeJoystream = null; ++ object.hasMarketing = false; ++ object.isPublic = false; ++ object.isExplicit = false; ++ object.category = ""; ++ object.enableComments = false; ++ object.clearSubtitles = false; ++ } ++ if (message.title != null && message.hasOwnProperty("title")) ++ object.title = message.title; ++ if (message.description != null && message.hasOwnProperty("description")) ++ object.description = message.description; ++ if (message.video != null && message.hasOwnProperty("video")) ++ object.video = message.video; ++ if (message.thumbnailPhoto != null && message.hasOwnProperty("thumbnailPhoto")) ++ object.thumbnailPhoto = message.thumbnailPhoto; ++ if (message.duration != null && message.hasOwnProperty("duration")) ++ object.duration = message.duration; ++ if (message.mediaPixelHeight != null && message.hasOwnProperty("mediaPixelHeight")) ++ object.mediaPixelHeight = message.mediaPixelHeight; ++ if (message.mediaPixelWidth != null && message.hasOwnProperty("mediaPixelWidth")) ++ object.mediaPixelWidth = message.mediaPixelWidth; ++ if (message.mediaType != null && message.hasOwnProperty("mediaType")) ++ object.mediaType = $root.MediaType.toObject(message.mediaType, options); ++ if (message.language != null && message.hasOwnProperty("language")) ++ object.language = message.language; ++ if (message.license != null && message.hasOwnProperty("license")) ++ object.license = $root.License.toObject(message.license, options); ++ if (message.publishedBeforeJoystream != null && message.hasOwnProperty("publishedBeforeJoystream")) ++ object.publishedBeforeJoystream = $root.PublishedBeforeJoystream.toObject(message.publishedBeforeJoystream, options); ++ if (message.hasMarketing != null && message.hasOwnProperty("hasMarketing")) ++ object.hasMarketing = message.hasMarketing; ++ if (message.isPublic != null && message.hasOwnProperty("isPublic")) ++ object.isPublic = message.isPublic; ++ if (message.isExplicit != null && message.hasOwnProperty("isExplicit")) ++ object.isExplicit = message.isExplicit; ++ if (message.persons && message.persons.length) { ++ object.persons = []; ++ for (var j = 0; j < message.persons.length; ++j) ++ if (typeof message.persons[j] === "number") ++ object.persons[j] = options.longs === String ? String(message.persons[j]) : message.persons[j]; ++ else ++ object.persons[j] = options.longs === String ? $util.Long.prototype.toString.call(message.persons[j]) : options.longs === Number ? new $util.LongBits(message.persons[j].low >>> 0, message.persons[j].high >>> 0).toNumber(true) : message.persons[j]; ++ } ++ if (message.category != null && message.hasOwnProperty("category")) ++ object.category = message.category; ++ if (message.subtitles && message.subtitles.length) { ++ object.subtitles = []; ++ for (var j = 0; j < message.subtitles.length; ++j) ++ object.subtitles[j] = $root.SubtitleMetadata.toObject(message.subtitles[j], options); ++ } ++ if (message.enableComments != null && message.hasOwnProperty("enableComments")) ++ object.enableComments = message.enableComments; ++ if (message.clearSubtitles != null && message.hasOwnProperty("clearSubtitles")) ++ object.clearSubtitles = message.clearSubtitles; ++ return object; ++ }; ++ ++ /** ++ * Converts this VideoMetadata to JSON. ++ * @function toJSON ++ * @memberof VideoMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ VideoMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return VideoMetadata; ++})(); ++ ++$root.ContentMetadata = (function() { ++ ++ /** ++ * Properties of a ContentMetadata. ++ * @exports IContentMetadata ++ * @interface IContentMetadata ++ * @property {IVideoMetadata|null} [videoMetadata] ContentMetadata videoMetadata ++ */ ++ ++ /** ++ * Constructs a new ContentMetadata. ++ * @exports ContentMetadata ++ * @classdesc Represents a ContentMetadata. ++ * @implements IContentMetadata ++ * @constructor ++ * @param {IContentMetadata=} [properties] Properties to set ++ */ ++ function ContentMetadata(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * ContentMetadata videoMetadata. ++ * @member {IVideoMetadata|null|undefined} videoMetadata ++ * @memberof ContentMetadata ++ * @instance ++ */ ++ ContentMetadata.prototype.videoMetadata = null; ++ ++ // OneOf field names bound to virtual getters and setters ++ var $oneOfFields; ++ ++ /** ++ * ContentMetadata contentMetadata. ++ * @member {"videoMetadata"|undefined} contentMetadata ++ * @memberof ContentMetadata ++ * @instance ++ */ ++ Object.defineProperty(ContentMetadata.prototype, "contentMetadata", { ++ get: $util.oneOfGetter($oneOfFields = ["videoMetadata"]), ++ set: $util.oneOfSetter($oneOfFields) ++ }); ++ ++ /** ++ * Creates a new ContentMetadata instance using the specified properties. ++ * @function create ++ * @memberof ContentMetadata ++ * @static ++ * @param {IContentMetadata=} [properties] Properties to set ++ * @returns {ContentMetadata} ContentMetadata instance ++ */ ++ ContentMetadata.create = function create(properties) { ++ return new ContentMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified ContentMetadata message. Does not implicitly {@link ContentMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof ContentMetadata ++ * @static ++ * @param {IContentMetadata} message ContentMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ContentMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.videoMetadata != null && Object.hasOwnProperty.call(message, "videoMetadata")) ++ $root.VideoMetadata.encode(message.videoMetadata, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified ContentMetadata message, length delimited. Does not implicitly {@link ContentMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof ContentMetadata ++ * @static ++ * @param {IContentMetadata} message ContentMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ContentMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a ContentMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof ContentMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {ContentMetadata} ContentMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ContentMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ContentMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.videoMetadata = $root.VideoMetadata.decode(reader, reader.uint32()); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a ContentMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof ContentMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {ContentMetadata} ContentMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ContentMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a ContentMetadata message. ++ * @function verify ++ * @memberof ContentMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ ContentMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ var properties = {}; ++ if (message.videoMetadata != null && message.hasOwnProperty("videoMetadata")) { ++ properties.contentMetadata = 1; ++ { ++ var error = $root.VideoMetadata.verify(message.videoMetadata); ++ if (error) ++ return "videoMetadata." + error; ++ } ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates a ContentMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof ContentMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {ContentMetadata} ContentMetadata ++ */ ++ ContentMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.ContentMetadata) ++ return object; ++ var message = new $root.ContentMetadata(); ++ if (object.videoMetadata != null) { ++ if (typeof object.videoMetadata !== "object") ++ throw TypeError(".ContentMetadata.videoMetadata: object expected"); ++ message.videoMetadata = $root.VideoMetadata.fromObject(object.videoMetadata); ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a ContentMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof ContentMetadata ++ * @static ++ * @param {ContentMetadata} message ContentMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ ContentMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (message.videoMetadata != null && message.hasOwnProperty("videoMetadata")) { ++ object.videoMetadata = $root.VideoMetadata.toObject(message.videoMetadata, options); ++ if (options.oneofs) ++ object.contentMetadata = "videoMetadata"; ++ } ++ return object; ++ }; ++ ++ /** ++ * Converts this ContentMetadata to JSON. ++ * @function toJSON ++ * @memberof ContentMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ ContentMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return ContentMetadata; ++})(); ++ ++$root.OpeningMetadata = (function() { ++ ++ /** ++ * Properties of an OpeningMetadata. ++ * @exports IOpeningMetadata ++ * @interface IOpeningMetadata ++ * @property {string|null} [shortDescription] OpeningMetadata shortDescription ++ * @property {string|null} [description] OpeningMetadata description ++ * @property {number|null} [hiringLimit] OpeningMetadata hiringLimit ++ * @property {number|null} [expectedEndingTimestamp] OpeningMetadata expectedEndingTimestamp ++ * @property {string|null} [applicationDetails] OpeningMetadata applicationDetails ++ * @property {Array.|null} [applicationFormQuestions] OpeningMetadata applicationFormQuestions ++ * @property {string|null} [title] OpeningMetadata title ++ */ ++ ++ /** ++ * Constructs a new OpeningMetadata. ++ * @exports OpeningMetadata ++ * @classdesc Represents an OpeningMetadata. ++ * @implements IOpeningMetadata ++ * @constructor ++ * @param {IOpeningMetadata=} [properties] Properties to set ++ */ ++ function OpeningMetadata(properties) { ++ this.applicationFormQuestions = []; ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * OpeningMetadata shortDescription. ++ * @member {string} shortDescription ++ * @memberof OpeningMetadata ++ * @instance ++ */ ++ OpeningMetadata.prototype.shortDescription = ""; ++ ++ /** ++ * OpeningMetadata description. ++ * @member {string} description ++ * @memberof OpeningMetadata ++ * @instance ++ */ ++ OpeningMetadata.prototype.description = ""; ++ ++ /** ++ * OpeningMetadata hiringLimit. ++ * @member {number} hiringLimit ++ * @memberof OpeningMetadata ++ * @instance ++ */ ++ OpeningMetadata.prototype.hiringLimit = 0; ++ ++ /** ++ * OpeningMetadata expectedEndingTimestamp. ++ * @member {number} expectedEndingTimestamp ++ * @memberof OpeningMetadata ++ * @instance ++ */ ++ OpeningMetadata.prototype.expectedEndingTimestamp = 0; ++ ++ /** ++ * OpeningMetadata applicationDetails. ++ * @member {string} applicationDetails ++ * @memberof OpeningMetadata ++ * @instance ++ */ ++ OpeningMetadata.prototype.applicationDetails = ""; ++ ++ /** ++ * OpeningMetadata applicationFormQuestions. ++ * @member {Array.} applicationFormQuestions ++ * @memberof OpeningMetadata ++ * @instance ++ */ ++ OpeningMetadata.prototype.applicationFormQuestions = $util.emptyArray; ++ ++ /** ++ * OpeningMetadata title. ++ * @member {string} title ++ * @memberof OpeningMetadata ++ * @instance ++ */ ++ OpeningMetadata.prototype.title = ""; ++ ++ /** ++ * Creates a new OpeningMetadata instance using the specified properties. ++ * @function create ++ * @memberof OpeningMetadata ++ * @static ++ * @param {IOpeningMetadata=} [properties] Properties to set ++ * @returns {OpeningMetadata} OpeningMetadata instance ++ */ ++ OpeningMetadata.create = function create(properties) { ++ return new OpeningMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified OpeningMetadata message. Does not implicitly {@link OpeningMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof OpeningMetadata ++ * @static ++ * @param {IOpeningMetadata} message OpeningMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ OpeningMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.shortDescription != null && Object.hasOwnProperty.call(message, "shortDescription")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.shortDescription); ++ if (message.description != null && Object.hasOwnProperty.call(message, "description")) ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.description); ++ if (message.hiringLimit != null && Object.hasOwnProperty.call(message, "hiringLimit")) ++ writer.uint32(/* id 3, wireType 0 =*/24).uint32(message.hiringLimit); ++ if (message.expectedEndingTimestamp != null && Object.hasOwnProperty.call(message, "expectedEndingTimestamp")) ++ writer.uint32(/* id 4, wireType 0 =*/32).uint32(message.expectedEndingTimestamp); ++ if (message.applicationDetails != null && Object.hasOwnProperty.call(message, "applicationDetails")) ++ writer.uint32(/* id 5, wireType 2 =*/42).string(message.applicationDetails); ++ if (message.applicationFormQuestions != null && message.applicationFormQuestions.length) ++ for (var i = 0; i < message.applicationFormQuestions.length; ++i) ++ $root.OpeningMetadata.ApplicationFormQuestion.encode(message.applicationFormQuestions[i], writer.uint32(/* id 6, wireType 2 =*/50).fork()).ldelim(); ++ if (message.title != null && Object.hasOwnProperty.call(message, "title")) ++ writer.uint32(/* id 7, wireType 2 =*/58).string(message.title); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified OpeningMetadata message, length delimited. Does not implicitly {@link OpeningMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof OpeningMetadata ++ * @static ++ * @param {IOpeningMetadata} message OpeningMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ OpeningMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes an OpeningMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof OpeningMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {OpeningMetadata} OpeningMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ OpeningMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.OpeningMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.shortDescription = reader.string(); ++ break; ++ case 2: ++ message.description = reader.string(); ++ break; ++ case 3: ++ message.hiringLimit = reader.uint32(); ++ break; ++ case 4: ++ message.expectedEndingTimestamp = reader.uint32(); ++ break; ++ case 5: ++ message.applicationDetails = reader.string(); ++ break; ++ case 6: ++ if (!(message.applicationFormQuestions && message.applicationFormQuestions.length)) ++ message.applicationFormQuestions = []; ++ message.applicationFormQuestions.push($root.OpeningMetadata.ApplicationFormQuestion.decode(reader, reader.uint32())); ++ break; ++ case 7: ++ message.title = reader.string(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes an OpeningMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof OpeningMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {OpeningMetadata} OpeningMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ OpeningMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies an OpeningMetadata message. ++ * @function verify ++ * @memberof OpeningMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ OpeningMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.shortDescription != null && message.hasOwnProperty("shortDescription")) ++ if (!$util.isString(message.shortDescription)) ++ return "shortDescription: string expected"; ++ if (message.description != null && message.hasOwnProperty("description")) ++ if (!$util.isString(message.description)) ++ return "description: string expected"; ++ if (message.hiringLimit != null && message.hasOwnProperty("hiringLimit")) ++ if (!$util.isInteger(message.hiringLimit)) ++ return "hiringLimit: integer expected"; ++ if (message.expectedEndingTimestamp != null && message.hasOwnProperty("expectedEndingTimestamp")) ++ if (!$util.isInteger(message.expectedEndingTimestamp)) ++ return "expectedEndingTimestamp: integer expected"; ++ if (message.applicationDetails != null && message.hasOwnProperty("applicationDetails")) ++ if (!$util.isString(message.applicationDetails)) ++ return "applicationDetails: string expected"; ++ if (message.applicationFormQuestions != null && message.hasOwnProperty("applicationFormQuestions")) { ++ if (!Array.isArray(message.applicationFormQuestions)) ++ return "applicationFormQuestions: array expected"; ++ for (var i = 0; i < message.applicationFormQuestions.length; ++i) { ++ var error = $root.OpeningMetadata.ApplicationFormQuestion.verify(message.applicationFormQuestions[i]); ++ if (error) ++ return "applicationFormQuestions." + error; ++ } ++ } ++ if (message.title != null && message.hasOwnProperty("title")) ++ if (!$util.isString(message.title)) ++ return "title: string expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates an OpeningMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof OpeningMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {OpeningMetadata} OpeningMetadata ++ */ ++ OpeningMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.OpeningMetadata) ++ return object; ++ var message = new $root.OpeningMetadata(); ++ if (object.shortDescription != null) ++ message.shortDescription = String(object.shortDescription); ++ if (object.description != null) ++ message.description = String(object.description); ++ if (object.hiringLimit != null) ++ message.hiringLimit = object.hiringLimit >>> 0; ++ if (object.expectedEndingTimestamp != null) ++ message.expectedEndingTimestamp = object.expectedEndingTimestamp >>> 0; ++ if (object.applicationDetails != null) ++ message.applicationDetails = String(object.applicationDetails); ++ if (object.applicationFormQuestions) { ++ if (!Array.isArray(object.applicationFormQuestions)) ++ throw TypeError(".OpeningMetadata.applicationFormQuestions: array expected"); ++ message.applicationFormQuestions = []; ++ for (var i = 0; i < object.applicationFormQuestions.length; ++i) { ++ if (typeof object.applicationFormQuestions[i] !== "object") ++ throw TypeError(".OpeningMetadata.applicationFormQuestions: object expected"); ++ message.applicationFormQuestions[i] = $root.OpeningMetadata.ApplicationFormQuestion.fromObject(object.applicationFormQuestions[i]); ++ } ++ } ++ if (object.title != null) ++ message.title = String(object.title); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from an OpeningMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof OpeningMetadata ++ * @static ++ * @param {OpeningMetadata} message OpeningMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ OpeningMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.arrays || options.defaults) ++ object.applicationFormQuestions = []; ++ if (options.defaults) { ++ object.shortDescription = ""; ++ object.description = ""; ++ object.hiringLimit = 0; ++ object.expectedEndingTimestamp = 0; ++ object.applicationDetails = ""; ++ object.title = ""; ++ } ++ if (message.shortDescription != null && message.hasOwnProperty("shortDescription")) ++ object.shortDescription = message.shortDescription; ++ if (message.description != null && message.hasOwnProperty("description")) ++ object.description = message.description; ++ if (message.hiringLimit != null && message.hasOwnProperty("hiringLimit")) ++ object.hiringLimit = message.hiringLimit; ++ if (message.expectedEndingTimestamp != null && message.hasOwnProperty("expectedEndingTimestamp")) ++ object.expectedEndingTimestamp = message.expectedEndingTimestamp; ++ if (message.applicationDetails != null && message.hasOwnProperty("applicationDetails")) ++ object.applicationDetails = message.applicationDetails; ++ if (message.applicationFormQuestions && message.applicationFormQuestions.length) { ++ object.applicationFormQuestions = []; ++ for (var j = 0; j < message.applicationFormQuestions.length; ++j) ++ object.applicationFormQuestions[j] = $root.OpeningMetadata.ApplicationFormQuestion.toObject(message.applicationFormQuestions[j], options); ++ } ++ if (message.title != null && message.hasOwnProperty("title")) ++ object.title = message.title; ++ return object; ++ }; ++ ++ /** ++ * Converts this OpeningMetadata to JSON. ++ * @function toJSON ++ * @memberof OpeningMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ OpeningMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ OpeningMetadata.ApplicationFormQuestion = (function() { ++ ++ /** ++ * Properties of an ApplicationFormQuestion. ++ * @memberof OpeningMetadata ++ * @interface IApplicationFormQuestion ++ * @property {string|null} [question] ApplicationFormQuestion question ++ * @property {OpeningMetadata.ApplicationFormQuestion.InputType|null} [type] ApplicationFormQuestion type ++ */ ++ ++ /** ++ * Constructs a new ApplicationFormQuestion. ++ * @memberof OpeningMetadata ++ * @classdesc Represents an ApplicationFormQuestion. ++ * @implements IApplicationFormQuestion ++ * @constructor ++ * @param {OpeningMetadata.IApplicationFormQuestion=} [properties] Properties to set ++ */ ++ function ApplicationFormQuestion(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * ApplicationFormQuestion question. ++ * @member {string} question ++ * @memberof OpeningMetadata.ApplicationFormQuestion ++ * @instance ++ */ ++ ApplicationFormQuestion.prototype.question = ""; ++ ++ /** ++ * ApplicationFormQuestion type. ++ * @member {OpeningMetadata.ApplicationFormQuestion.InputType} type ++ * @memberof OpeningMetadata.ApplicationFormQuestion ++ * @instance ++ */ ++ ApplicationFormQuestion.prototype.type = 0; ++ ++ /** ++ * Creates a new ApplicationFormQuestion instance using the specified properties. ++ * @function create ++ * @memberof OpeningMetadata.ApplicationFormQuestion ++ * @static ++ * @param {OpeningMetadata.IApplicationFormQuestion=} [properties] Properties to set ++ * @returns {OpeningMetadata.ApplicationFormQuestion} ApplicationFormQuestion instance ++ */ ++ ApplicationFormQuestion.create = function create(properties) { ++ return new ApplicationFormQuestion(properties); ++ }; ++ ++ /** ++ * Encodes the specified ApplicationFormQuestion message. Does not implicitly {@link OpeningMetadata.ApplicationFormQuestion.verify|verify} messages. ++ * @function encode ++ * @memberof OpeningMetadata.ApplicationFormQuestion ++ * @static ++ * @param {OpeningMetadata.IApplicationFormQuestion} message ApplicationFormQuestion message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ApplicationFormQuestion.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.question != null && Object.hasOwnProperty.call(message, "question")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.question); ++ if (message.type != null && Object.hasOwnProperty.call(message, "type")) ++ writer.uint32(/* id 2, wireType 0 =*/16).int32(message.type); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified ApplicationFormQuestion message, length delimited. Does not implicitly {@link OpeningMetadata.ApplicationFormQuestion.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof OpeningMetadata.ApplicationFormQuestion ++ * @static ++ * @param {OpeningMetadata.IApplicationFormQuestion} message ApplicationFormQuestion message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ApplicationFormQuestion.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes an ApplicationFormQuestion message from the specified reader or buffer. ++ * @function decode ++ * @memberof OpeningMetadata.ApplicationFormQuestion ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {OpeningMetadata.ApplicationFormQuestion} ApplicationFormQuestion ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ApplicationFormQuestion.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.OpeningMetadata.ApplicationFormQuestion(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.question = reader.string(); ++ break; ++ case 2: ++ message.type = reader.int32(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes an ApplicationFormQuestion message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof OpeningMetadata.ApplicationFormQuestion ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {OpeningMetadata.ApplicationFormQuestion} ApplicationFormQuestion ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ApplicationFormQuestion.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies an ApplicationFormQuestion message. ++ * @function verify ++ * @memberof OpeningMetadata.ApplicationFormQuestion ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ ApplicationFormQuestion.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.question != null && message.hasOwnProperty("question")) ++ if (!$util.isString(message.question)) ++ return "question: string expected"; ++ if (message.type != null && message.hasOwnProperty("type")) ++ switch (message.type) { ++ default: ++ return "type: enum value expected"; ++ case 0: ++ case 1: ++ break; ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates an ApplicationFormQuestion message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof OpeningMetadata.ApplicationFormQuestion ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {OpeningMetadata.ApplicationFormQuestion} ApplicationFormQuestion ++ */ ++ ApplicationFormQuestion.fromObject = function fromObject(object) { ++ if (object instanceof $root.OpeningMetadata.ApplicationFormQuestion) ++ return object; ++ var message = new $root.OpeningMetadata.ApplicationFormQuestion(); ++ if (object.question != null) ++ message.question = String(object.question); ++ switch (object.type) { ++ case "TEXTAREA": ++ case 0: ++ message.type = 0; ++ break; ++ case "TEXT": ++ case 1: ++ message.type = 1; ++ break; ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from an ApplicationFormQuestion message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof OpeningMetadata.ApplicationFormQuestion ++ * @static ++ * @param {OpeningMetadata.ApplicationFormQuestion} message ApplicationFormQuestion ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ ApplicationFormQuestion.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.question = ""; ++ object.type = options.enums === String ? "TEXTAREA" : 0; ++ } ++ if (message.question != null && message.hasOwnProperty("question")) ++ object.question = message.question; ++ if (message.type != null && message.hasOwnProperty("type")) ++ object.type = options.enums === String ? $root.OpeningMetadata.ApplicationFormQuestion.InputType[message.type] : message.type; ++ return object; ++ }; ++ ++ /** ++ * Converts this ApplicationFormQuestion to JSON. ++ * @function toJSON ++ * @memberof OpeningMetadata.ApplicationFormQuestion ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ ApplicationFormQuestion.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ /** ++ * InputType enum. ++ * @name OpeningMetadata.ApplicationFormQuestion.InputType ++ * @enum {number} ++ * @property {number} TEXTAREA=0 TEXTAREA value ++ * @property {number} TEXT=1 TEXT value ++ */ ++ ApplicationFormQuestion.InputType = (function() { ++ var valuesById = {}, values = Object.create(valuesById); ++ values[valuesById[0] = "TEXTAREA"] = 0; ++ values[valuesById[1] = "TEXT"] = 1; ++ return values; ++ })(); ++ ++ return ApplicationFormQuestion; ++ })(); ++ ++ return OpeningMetadata; ++})(); ++ ++$root.UpcomingOpeningMetadata = (function() { ++ ++ /** ++ * Properties of an UpcomingOpeningMetadata. ++ * @exports IUpcomingOpeningMetadata ++ * @interface IUpcomingOpeningMetadata ++ * @property {number|null} [expectedStart] UpcomingOpeningMetadata expectedStart ++ * @property {Long|null} [rewardPerBlock] UpcomingOpeningMetadata rewardPerBlock ++ * @property {Long|null} [minApplicationStake] UpcomingOpeningMetadata minApplicationStake ++ * @property {IOpeningMetadata|null} [metadata] UpcomingOpeningMetadata metadata ++ */ ++ ++ /** ++ * Constructs a new UpcomingOpeningMetadata. ++ * @exports UpcomingOpeningMetadata ++ * @classdesc Represents an UpcomingOpeningMetadata. ++ * @implements IUpcomingOpeningMetadata ++ * @constructor ++ * @param {IUpcomingOpeningMetadata=} [properties] Properties to set ++ */ ++ function UpcomingOpeningMetadata(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * UpcomingOpeningMetadata expectedStart. ++ * @member {number} expectedStart ++ * @memberof UpcomingOpeningMetadata ++ * @instance ++ */ ++ UpcomingOpeningMetadata.prototype.expectedStart = 0; ++ ++ /** ++ * UpcomingOpeningMetadata rewardPerBlock. ++ * @member {Long} rewardPerBlock ++ * @memberof UpcomingOpeningMetadata ++ * @instance ++ */ ++ UpcomingOpeningMetadata.prototype.rewardPerBlock = $util.Long ? $util.Long.fromBits(0,0,true) : 0; ++ ++ /** ++ * UpcomingOpeningMetadata minApplicationStake. ++ * @member {Long} minApplicationStake ++ * @memberof UpcomingOpeningMetadata ++ * @instance ++ */ ++ UpcomingOpeningMetadata.prototype.minApplicationStake = $util.Long ? $util.Long.fromBits(0,0,true) : 0; ++ ++ /** ++ * UpcomingOpeningMetadata metadata. ++ * @member {IOpeningMetadata|null|undefined} metadata ++ * @memberof UpcomingOpeningMetadata ++ * @instance ++ */ ++ UpcomingOpeningMetadata.prototype.metadata = null; ++ ++ /** ++ * Creates a new UpcomingOpeningMetadata instance using the specified properties. ++ * @function create ++ * @memberof UpcomingOpeningMetadata ++ * @static ++ * @param {IUpcomingOpeningMetadata=} [properties] Properties to set ++ * @returns {UpcomingOpeningMetadata} UpcomingOpeningMetadata instance ++ */ ++ UpcomingOpeningMetadata.create = function create(properties) { ++ return new UpcomingOpeningMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified UpcomingOpeningMetadata message. Does not implicitly {@link UpcomingOpeningMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof UpcomingOpeningMetadata ++ * @static ++ * @param {IUpcomingOpeningMetadata} message UpcomingOpeningMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ UpcomingOpeningMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.expectedStart != null && Object.hasOwnProperty.call(message, "expectedStart")) ++ writer.uint32(/* id 1, wireType 0 =*/8).uint32(message.expectedStart); ++ if (message.rewardPerBlock != null && Object.hasOwnProperty.call(message, "rewardPerBlock")) ++ writer.uint32(/* id 2, wireType 0 =*/16).uint64(message.rewardPerBlock); ++ if (message.minApplicationStake != null && Object.hasOwnProperty.call(message, "minApplicationStake")) ++ writer.uint32(/* id 3, wireType 0 =*/24).uint64(message.minApplicationStake); ++ if (message.metadata != null && Object.hasOwnProperty.call(message, "metadata")) ++ $root.OpeningMetadata.encode(message.metadata, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim(); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified UpcomingOpeningMetadata message, length delimited. Does not implicitly {@link UpcomingOpeningMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof UpcomingOpeningMetadata ++ * @static ++ * @param {IUpcomingOpeningMetadata} message UpcomingOpeningMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ UpcomingOpeningMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes an UpcomingOpeningMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof UpcomingOpeningMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {UpcomingOpeningMetadata} UpcomingOpeningMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ UpcomingOpeningMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.UpcomingOpeningMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.expectedStart = reader.uint32(); ++ break; ++ case 2: ++ message.rewardPerBlock = reader.uint64(); ++ break; ++ case 3: ++ message.minApplicationStake = reader.uint64(); ++ break; ++ case 4: ++ message.metadata = $root.OpeningMetadata.decode(reader, reader.uint32()); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes an UpcomingOpeningMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof UpcomingOpeningMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {UpcomingOpeningMetadata} UpcomingOpeningMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ UpcomingOpeningMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies an UpcomingOpeningMetadata message. ++ * @function verify ++ * @memberof UpcomingOpeningMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ UpcomingOpeningMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.expectedStart != null && message.hasOwnProperty("expectedStart")) ++ if (!$util.isInteger(message.expectedStart)) ++ return "expectedStart: integer expected"; ++ if (message.rewardPerBlock != null && message.hasOwnProperty("rewardPerBlock")) ++ if (!$util.isInteger(message.rewardPerBlock) && !(message.rewardPerBlock && $util.isInteger(message.rewardPerBlock.low) && $util.isInteger(message.rewardPerBlock.high))) ++ return "rewardPerBlock: integer|Long expected"; ++ if (message.minApplicationStake != null && message.hasOwnProperty("minApplicationStake")) ++ if (!$util.isInteger(message.minApplicationStake) && !(message.minApplicationStake && $util.isInteger(message.minApplicationStake.low) && $util.isInteger(message.minApplicationStake.high))) ++ return "minApplicationStake: integer|Long expected"; ++ if (message.metadata != null && message.hasOwnProperty("metadata")) { ++ var error = $root.OpeningMetadata.verify(message.metadata); ++ if (error) ++ return "metadata." + error; ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates an UpcomingOpeningMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof UpcomingOpeningMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {UpcomingOpeningMetadata} UpcomingOpeningMetadata ++ */ ++ UpcomingOpeningMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.UpcomingOpeningMetadata) ++ return object; ++ var message = new $root.UpcomingOpeningMetadata(); ++ if (object.expectedStart != null) ++ message.expectedStart = object.expectedStart >>> 0; ++ if (object.rewardPerBlock != null) ++ if ($util.Long) ++ (message.rewardPerBlock = $util.Long.fromValue(object.rewardPerBlock)).unsigned = true; ++ else if (typeof object.rewardPerBlock === "string") ++ message.rewardPerBlock = parseInt(object.rewardPerBlock, 10); ++ else if (typeof object.rewardPerBlock === "number") ++ message.rewardPerBlock = object.rewardPerBlock; ++ else if (typeof object.rewardPerBlock === "object") ++ message.rewardPerBlock = new $util.LongBits(object.rewardPerBlock.low >>> 0, object.rewardPerBlock.high >>> 0).toNumber(true); ++ if (object.minApplicationStake != null) ++ if ($util.Long) ++ (message.minApplicationStake = $util.Long.fromValue(object.minApplicationStake)).unsigned = true; ++ else if (typeof object.minApplicationStake === "string") ++ message.minApplicationStake = parseInt(object.minApplicationStake, 10); ++ else if (typeof object.minApplicationStake === "number") ++ message.minApplicationStake = object.minApplicationStake; ++ else if (typeof object.minApplicationStake === "object") ++ message.minApplicationStake = new $util.LongBits(object.minApplicationStake.low >>> 0, object.minApplicationStake.high >>> 0).toNumber(true); ++ if (object.metadata != null) { ++ if (typeof object.metadata !== "object") ++ throw TypeError(".UpcomingOpeningMetadata.metadata: object expected"); ++ message.metadata = $root.OpeningMetadata.fromObject(object.metadata); ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from an UpcomingOpeningMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof UpcomingOpeningMetadata ++ * @static ++ * @param {UpcomingOpeningMetadata} message UpcomingOpeningMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ UpcomingOpeningMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.expectedStart = 0; ++ if ($util.Long) { ++ var long = new $util.Long(0, 0, true); ++ object.rewardPerBlock = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; ++ } else ++ object.rewardPerBlock = options.longs === String ? "0" : 0; ++ if ($util.Long) { ++ var long = new $util.Long(0, 0, true); ++ object.minApplicationStake = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; ++ } else ++ object.minApplicationStake = options.longs === String ? "0" : 0; ++ object.metadata = null; ++ } ++ if (message.expectedStart != null && message.hasOwnProperty("expectedStart")) ++ object.expectedStart = message.expectedStart; ++ if (message.rewardPerBlock != null && message.hasOwnProperty("rewardPerBlock")) ++ if (typeof message.rewardPerBlock === "number") ++ object.rewardPerBlock = options.longs === String ? String(message.rewardPerBlock) : message.rewardPerBlock; ++ else ++ object.rewardPerBlock = options.longs === String ? $util.Long.prototype.toString.call(message.rewardPerBlock) : options.longs === Number ? new $util.LongBits(message.rewardPerBlock.low >>> 0, message.rewardPerBlock.high >>> 0).toNumber(true) : message.rewardPerBlock; ++ if (message.minApplicationStake != null && message.hasOwnProperty("minApplicationStake")) ++ if (typeof message.minApplicationStake === "number") ++ object.minApplicationStake = options.longs === String ? String(message.minApplicationStake) : message.minApplicationStake; ++ else ++ object.minApplicationStake = options.longs === String ? $util.Long.prototype.toString.call(message.minApplicationStake) : options.longs === Number ? new $util.LongBits(message.minApplicationStake.low >>> 0, message.minApplicationStake.high >>> 0).toNumber(true) : message.minApplicationStake; ++ if (message.metadata != null && message.hasOwnProperty("metadata")) ++ object.metadata = $root.OpeningMetadata.toObject(message.metadata, options); ++ return object; ++ }; ++ ++ /** ++ * Converts this UpcomingOpeningMetadata to JSON. ++ * @function toJSON ++ * @memberof UpcomingOpeningMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ UpcomingOpeningMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return UpcomingOpeningMetadata; ++})(); ++ ++$root.ApplicationMetadata = (function() { ++ ++ /** ++ * Properties of an ApplicationMetadata. ++ * @exports IApplicationMetadata ++ * @interface IApplicationMetadata ++ * @property {Array.|null} [answers] ApplicationMetadata answers ++ */ ++ ++ /** ++ * Constructs a new ApplicationMetadata. ++ * @exports ApplicationMetadata ++ * @classdesc Represents an ApplicationMetadata. ++ * @implements IApplicationMetadata ++ * @constructor ++ * @param {IApplicationMetadata=} [properties] Properties to set ++ */ ++ function ApplicationMetadata(properties) { ++ this.answers = []; ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * ApplicationMetadata answers. ++ * @member {Array.} answers ++ * @memberof ApplicationMetadata ++ * @instance ++ */ ++ ApplicationMetadata.prototype.answers = $util.emptyArray; ++ ++ /** ++ * Creates a new ApplicationMetadata instance using the specified properties. ++ * @function create ++ * @memberof ApplicationMetadata ++ * @static ++ * @param {IApplicationMetadata=} [properties] Properties to set ++ * @returns {ApplicationMetadata} ApplicationMetadata instance ++ */ ++ ApplicationMetadata.create = function create(properties) { ++ return new ApplicationMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified ApplicationMetadata message. Does not implicitly {@link ApplicationMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof ApplicationMetadata ++ * @static ++ * @param {IApplicationMetadata} message ApplicationMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ApplicationMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.answers != null && message.answers.length) ++ for (var i = 0; i < message.answers.length; ++i) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.answers[i]); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified ApplicationMetadata message, length delimited. Does not implicitly {@link ApplicationMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof ApplicationMetadata ++ * @static ++ * @param {IApplicationMetadata} message ApplicationMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ApplicationMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes an ApplicationMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof ApplicationMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {ApplicationMetadata} ApplicationMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ApplicationMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ApplicationMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ if (!(message.answers && message.answers.length)) ++ message.answers = []; ++ message.answers.push(reader.string()); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes an ApplicationMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof ApplicationMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {ApplicationMetadata} ApplicationMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ApplicationMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies an ApplicationMetadata message. ++ * @function verify ++ * @memberof ApplicationMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ ApplicationMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.answers != null && message.hasOwnProperty("answers")) { ++ if (!Array.isArray(message.answers)) ++ return "answers: array expected"; ++ for (var i = 0; i < message.answers.length; ++i) ++ if (!$util.isString(message.answers[i])) ++ return "answers: string[] expected"; ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates an ApplicationMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof ApplicationMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {ApplicationMetadata} ApplicationMetadata ++ */ ++ ApplicationMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.ApplicationMetadata) ++ return object; ++ var message = new $root.ApplicationMetadata(); ++ if (object.answers) { ++ if (!Array.isArray(object.answers)) ++ throw TypeError(".ApplicationMetadata.answers: array expected"); ++ message.answers = []; ++ for (var i = 0; i < object.answers.length; ++i) ++ message.answers[i] = String(object.answers[i]); ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from an ApplicationMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof ApplicationMetadata ++ * @static ++ * @param {ApplicationMetadata} message ApplicationMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ ApplicationMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.arrays || options.defaults) ++ object.answers = []; ++ if (message.answers && message.answers.length) { ++ object.answers = []; ++ for (var j = 0; j < message.answers.length; ++j) ++ object.answers[j] = message.answers[j]; ++ } ++ return object; ++ }; ++ ++ /** ++ * Converts this ApplicationMetadata to JSON. ++ * @function toJSON ++ * @memberof ApplicationMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ ApplicationMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return ApplicationMetadata; ++})(); ++ ++$root.WorkingGroupMetadata = (function() { ++ ++ /** ++ * Properties of a WorkingGroupMetadata. ++ * @exports IWorkingGroupMetadata ++ * @interface IWorkingGroupMetadata ++ * @property {string|null} [description] WorkingGroupMetadata description ++ * @property {string|null} [about] WorkingGroupMetadata about ++ * @property {string|null} [status] WorkingGroupMetadata status ++ * @property {string|null} [statusMessage] WorkingGroupMetadata statusMessage ++ */ ++ ++ /** ++ * Constructs a new WorkingGroupMetadata. ++ * @exports WorkingGroupMetadata ++ * @classdesc Represents a WorkingGroupMetadata. ++ * @implements IWorkingGroupMetadata ++ * @constructor ++ * @param {IWorkingGroupMetadata=} [properties] Properties to set ++ */ ++ function WorkingGroupMetadata(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * WorkingGroupMetadata description. ++ * @member {string} description ++ * @memberof WorkingGroupMetadata ++ * @instance ++ */ ++ WorkingGroupMetadata.prototype.description = ""; ++ ++ /** ++ * WorkingGroupMetadata about. ++ * @member {string} about ++ * @memberof WorkingGroupMetadata ++ * @instance ++ */ ++ WorkingGroupMetadata.prototype.about = ""; ++ ++ /** ++ * WorkingGroupMetadata status. ++ * @member {string} status ++ * @memberof WorkingGroupMetadata ++ * @instance ++ */ ++ WorkingGroupMetadata.prototype.status = ""; ++ ++ /** ++ * WorkingGroupMetadata statusMessage. ++ * @member {string} statusMessage ++ * @memberof WorkingGroupMetadata ++ * @instance ++ */ ++ WorkingGroupMetadata.prototype.statusMessage = ""; ++ ++ /** ++ * Creates a new WorkingGroupMetadata instance using the specified properties. ++ * @function create ++ * @memberof WorkingGroupMetadata ++ * @static ++ * @param {IWorkingGroupMetadata=} [properties] Properties to set ++ * @returns {WorkingGroupMetadata} WorkingGroupMetadata instance ++ */ ++ WorkingGroupMetadata.create = function create(properties) { ++ return new WorkingGroupMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified WorkingGroupMetadata message. Does not implicitly {@link WorkingGroupMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof WorkingGroupMetadata ++ * @static ++ * @param {IWorkingGroupMetadata} message WorkingGroupMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ WorkingGroupMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.description != null && Object.hasOwnProperty.call(message, "description")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.description); ++ if (message.about != null && Object.hasOwnProperty.call(message, "about")) ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.about); ++ if (message.status != null && Object.hasOwnProperty.call(message, "status")) ++ writer.uint32(/* id 3, wireType 2 =*/26).string(message.status); ++ if (message.statusMessage != null && Object.hasOwnProperty.call(message, "statusMessage")) ++ writer.uint32(/* id 4, wireType 2 =*/34).string(message.statusMessage); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified WorkingGroupMetadata message, length delimited. Does not implicitly {@link WorkingGroupMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof WorkingGroupMetadata ++ * @static ++ * @param {IWorkingGroupMetadata} message WorkingGroupMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ WorkingGroupMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a WorkingGroupMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof WorkingGroupMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {WorkingGroupMetadata} WorkingGroupMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ WorkingGroupMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.WorkingGroupMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.description = reader.string(); ++ break; ++ case 2: ++ message.about = reader.string(); ++ break; ++ case 3: ++ message.status = reader.string(); ++ break; ++ case 4: ++ message.statusMessage = reader.string(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a WorkingGroupMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof WorkingGroupMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {WorkingGroupMetadata} WorkingGroupMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ WorkingGroupMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a WorkingGroupMetadata message. ++ * @function verify ++ * @memberof WorkingGroupMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ WorkingGroupMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.description != null && message.hasOwnProperty("description")) ++ if (!$util.isString(message.description)) ++ return "description: string expected"; ++ if (message.about != null && message.hasOwnProperty("about")) ++ if (!$util.isString(message.about)) ++ return "about: string expected"; ++ if (message.status != null && message.hasOwnProperty("status")) ++ if (!$util.isString(message.status)) ++ return "status: string expected"; ++ if (message.statusMessage != null && message.hasOwnProperty("statusMessage")) ++ if (!$util.isString(message.statusMessage)) ++ return "statusMessage: string expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a WorkingGroupMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof WorkingGroupMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {WorkingGroupMetadata} WorkingGroupMetadata ++ */ ++ WorkingGroupMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.WorkingGroupMetadata) ++ return object; ++ var message = new $root.WorkingGroupMetadata(); ++ if (object.description != null) ++ message.description = String(object.description); ++ if (object.about != null) ++ message.about = String(object.about); ++ if (object.status != null) ++ message.status = String(object.status); ++ if (object.statusMessage != null) ++ message.statusMessage = String(object.statusMessage); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a WorkingGroupMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof WorkingGroupMetadata ++ * @static ++ * @param {WorkingGroupMetadata} message WorkingGroupMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ WorkingGroupMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ object.description = ""; ++ object.about = ""; ++ object.status = ""; ++ object.statusMessage = ""; ++ } ++ if (message.description != null && message.hasOwnProperty("description")) ++ object.description = message.description; ++ if (message.about != null && message.hasOwnProperty("about")) ++ object.about = message.about; ++ if (message.status != null && message.hasOwnProperty("status")) ++ object.status = message.status; ++ if (message.statusMessage != null && message.hasOwnProperty("statusMessage")) ++ object.statusMessage = message.statusMessage; ++ return object; ++ }; ++ ++ /** ++ * Converts this WorkingGroupMetadata to JSON. ++ * @function toJSON ++ * @memberof WorkingGroupMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ WorkingGroupMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return WorkingGroupMetadata; ++})(); ++ ++$root.SetGroupMetadata = (function() { ++ ++ /** ++ * Properties of a SetGroupMetadata. ++ * @exports ISetGroupMetadata ++ * @interface ISetGroupMetadata ++ * @property {IWorkingGroupMetadata|null} [newMetadata] SetGroupMetadata newMetadata ++ */ ++ ++ /** ++ * Constructs a new SetGroupMetadata. ++ * @exports SetGroupMetadata ++ * @classdesc Represents a SetGroupMetadata. ++ * @implements ISetGroupMetadata ++ * @constructor ++ * @param {ISetGroupMetadata=} [properties] Properties to set ++ */ ++ function SetGroupMetadata(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * SetGroupMetadata newMetadata. ++ * @member {IWorkingGroupMetadata|null|undefined} newMetadata ++ * @memberof SetGroupMetadata ++ * @instance ++ */ ++ SetGroupMetadata.prototype.newMetadata = null; ++ ++ /** ++ * Creates a new SetGroupMetadata instance using the specified properties. ++ * @function create ++ * @memberof SetGroupMetadata ++ * @static ++ * @param {ISetGroupMetadata=} [properties] Properties to set ++ * @returns {SetGroupMetadata} SetGroupMetadata instance ++ */ ++ SetGroupMetadata.create = function create(properties) { ++ return new SetGroupMetadata(properties); ++ }; ++ ++ /** ++ * Encodes the specified SetGroupMetadata message. Does not implicitly {@link SetGroupMetadata.verify|verify} messages. ++ * @function encode ++ * @memberof SetGroupMetadata ++ * @static ++ * @param {ISetGroupMetadata} message SetGroupMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ SetGroupMetadata.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.newMetadata != null && Object.hasOwnProperty.call(message, "newMetadata")) ++ $root.WorkingGroupMetadata.encode(message.newMetadata, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified SetGroupMetadata message, length delimited. Does not implicitly {@link SetGroupMetadata.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof SetGroupMetadata ++ * @static ++ * @param {ISetGroupMetadata} message SetGroupMetadata message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ SetGroupMetadata.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a SetGroupMetadata message from the specified reader or buffer. ++ * @function decode ++ * @memberof SetGroupMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {SetGroupMetadata} SetGroupMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ SetGroupMetadata.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.SetGroupMetadata(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.newMetadata = $root.WorkingGroupMetadata.decode(reader, reader.uint32()); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a SetGroupMetadata message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof SetGroupMetadata ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {SetGroupMetadata} SetGroupMetadata ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ SetGroupMetadata.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a SetGroupMetadata message. ++ * @function verify ++ * @memberof SetGroupMetadata ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ SetGroupMetadata.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.newMetadata != null && message.hasOwnProperty("newMetadata")) { ++ var error = $root.WorkingGroupMetadata.verify(message.newMetadata); ++ if (error) ++ return "newMetadata." + error; ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates a SetGroupMetadata message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof SetGroupMetadata ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {SetGroupMetadata} SetGroupMetadata ++ */ ++ SetGroupMetadata.fromObject = function fromObject(object) { ++ if (object instanceof $root.SetGroupMetadata) ++ return object; ++ var message = new $root.SetGroupMetadata(); ++ if (object.newMetadata != null) { ++ if (typeof object.newMetadata !== "object") ++ throw TypeError(".SetGroupMetadata.newMetadata: object expected"); ++ message.newMetadata = $root.WorkingGroupMetadata.fromObject(object.newMetadata); ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a SetGroupMetadata message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof SetGroupMetadata ++ * @static ++ * @param {SetGroupMetadata} message SetGroupMetadata ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ SetGroupMetadata.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) ++ object.newMetadata = null; ++ if (message.newMetadata != null && message.hasOwnProperty("newMetadata")) ++ object.newMetadata = $root.WorkingGroupMetadata.toObject(message.newMetadata, options); ++ return object; ++ }; ++ ++ /** ++ * Converts this SetGroupMetadata to JSON. ++ * @function toJSON ++ * @memberof SetGroupMetadata ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ SetGroupMetadata.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return SetGroupMetadata; ++})(); ++ ++$root.AddUpcomingOpening = (function() { ++ ++ /** ++ * Properties of an AddUpcomingOpening. ++ * @exports IAddUpcomingOpening ++ * @interface IAddUpcomingOpening ++ * @property {IUpcomingOpeningMetadata|null} [metadata] AddUpcomingOpening metadata ++ */ ++ ++ /** ++ * Constructs a new AddUpcomingOpening. ++ * @exports AddUpcomingOpening ++ * @classdesc Represents an AddUpcomingOpening. ++ * @implements IAddUpcomingOpening ++ * @constructor ++ * @param {IAddUpcomingOpening=} [properties] Properties to set ++ */ ++ function AddUpcomingOpening(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * AddUpcomingOpening metadata. ++ * @member {IUpcomingOpeningMetadata|null|undefined} metadata ++ * @memberof AddUpcomingOpening ++ * @instance ++ */ ++ AddUpcomingOpening.prototype.metadata = null; ++ ++ /** ++ * Creates a new AddUpcomingOpening instance using the specified properties. ++ * @function create ++ * @memberof AddUpcomingOpening ++ * @static ++ * @param {IAddUpcomingOpening=} [properties] Properties to set ++ * @returns {AddUpcomingOpening} AddUpcomingOpening instance ++ */ ++ AddUpcomingOpening.create = function create(properties) { ++ return new AddUpcomingOpening(properties); ++ }; ++ ++ /** ++ * Encodes the specified AddUpcomingOpening message. Does not implicitly {@link AddUpcomingOpening.verify|verify} messages. ++ * @function encode ++ * @memberof AddUpcomingOpening ++ * @static ++ * @param {IAddUpcomingOpening} message AddUpcomingOpening message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ AddUpcomingOpening.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.metadata != null && Object.hasOwnProperty.call(message, "metadata")) ++ $root.UpcomingOpeningMetadata.encode(message.metadata, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified AddUpcomingOpening message, length delimited. Does not implicitly {@link AddUpcomingOpening.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof AddUpcomingOpening ++ * @static ++ * @param {IAddUpcomingOpening} message AddUpcomingOpening message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ AddUpcomingOpening.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes an AddUpcomingOpening message from the specified reader or buffer. ++ * @function decode ++ * @memberof AddUpcomingOpening ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {AddUpcomingOpening} AddUpcomingOpening ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ AddUpcomingOpening.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.AddUpcomingOpening(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.metadata = $root.UpcomingOpeningMetadata.decode(reader, reader.uint32()); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes an AddUpcomingOpening message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof AddUpcomingOpening ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {AddUpcomingOpening} AddUpcomingOpening ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ AddUpcomingOpening.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies an AddUpcomingOpening message. ++ * @function verify ++ * @memberof AddUpcomingOpening ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ AddUpcomingOpening.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.metadata != null && message.hasOwnProperty("metadata")) { ++ var error = $root.UpcomingOpeningMetadata.verify(message.metadata); ++ if (error) ++ return "metadata." + error; ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates an AddUpcomingOpening message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof AddUpcomingOpening ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {AddUpcomingOpening} AddUpcomingOpening ++ */ ++ AddUpcomingOpening.fromObject = function fromObject(object) { ++ if (object instanceof $root.AddUpcomingOpening) ++ return object; ++ var message = new $root.AddUpcomingOpening(); ++ if (object.metadata != null) { ++ if (typeof object.metadata !== "object") ++ throw TypeError(".AddUpcomingOpening.metadata: object expected"); ++ message.metadata = $root.UpcomingOpeningMetadata.fromObject(object.metadata); ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from an AddUpcomingOpening message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof AddUpcomingOpening ++ * @static ++ * @param {AddUpcomingOpening} message AddUpcomingOpening ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ AddUpcomingOpening.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) ++ object.metadata = null; ++ if (message.metadata != null && message.hasOwnProperty("metadata")) ++ object.metadata = $root.UpcomingOpeningMetadata.toObject(message.metadata, options); ++ return object; ++ }; ++ ++ /** ++ * Converts this AddUpcomingOpening to JSON. ++ * @function toJSON ++ * @memberof AddUpcomingOpening ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ AddUpcomingOpening.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return AddUpcomingOpening; ++})(); ++ ++$root.RemoveUpcomingOpening = (function() { ++ ++ /** ++ * Properties of a RemoveUpcomingOpening. ++ * @exports IRemoveUpcomingOpening ++ * @interface IRemoveUpcomingOpening ++ * @property {string|null} [id] RemoveUpcomingOpening id ++ */ ++ ++ /** ++ * Constructs a new RemoveUpcomingOpening. ++ * @exports RemoveUpcomingOpening ++ * @classdesc Represents a RemoveUpcomingOpening. ++ * @implements IRemoveUpcomingOpening ++ * @constructor ++ * @param {IRemoveUpcomingOpening=} [properties] Properties to set ++ */ ++ function RemoveUpcomingOpening(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * RemoveUpcomingOpening id. ++ * @member {string} id ++ * @memberof RemoveUpcomingOpening ++ * @instance ++ */ ++ RemoveUpcomingOpening.prototype.id = ""; ++ ++ /** ++ * Creates a new RemoveUpcomingOpening instance using the specified properties. ++ * @function create ++ * @memberof RemoveUpcomingOpening ++ * @static ++ * @param {IRemoveUpcomingOpening=} [properties] Properties to set ++ * @returns {RemoveUpcomingOpening} RemoveUpcomingOpening instance ++ */ ++ RemoveUpcomingOpening.create = function create(properties) { ++ return new RemoveUpcomingOpening(properties); ++ }; ++ ++ /** ++ * Encodes the specified RemoveUpcomingOpening message. Does not implicitly {@link RemoveUpcomingOpening.verify|verify} messages. ++ * @function encode ++ * @memberof RemoveUpcomingOpening ++ * @static ++ * @param {IRemoveUpcomingOpening} message RemoveUpcomingOpening message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ RemoveUpcomingOpening.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.id != null && Object.hasOwnProperty.call(message, "id")) ++ writer.uint32(/* id 1, wireType 2 =*/10).string(message.id); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified RemoveUpcomingOpening message, length delimited. Does not implicitly {@link RemoveUpcomingOpening.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof RemoveUpcomingOpening ++ * @static ++ * @param {IRemoveUpcomingOpening} message RemoveUpcomingOpening message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ RemoveUpcomingOpening.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a RemoveUpcomingOpening message from the specified reader or buffer. ++ * @function decode ++ * @memberof RemoveUpcomingOpening ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {RemoveUpcomingOpening} RemoveUpcomingOpening ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ RemoveUpcomingOpening.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.RemoveUpcomingOpening(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.id = reader.string(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a RemoveUpcomingOpening message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof RemoveUpcomingOpening ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {RemoveUpcomingOpening} RemoveUpcomingOpening ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ RemoveUpcomingOpening.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a RemoveUpcomingOpening message. ++ * @function verify ++ * @memberof RemoveUpcomingOpening ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ RemoveUpcomingOpening.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (message.id != null && message.hasOwnProperty("id")) ++ if (!$util.isString(message.id)) ++ return "id: string expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a RemoveUpcomingOpening message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof RemoveUpcomingOpening ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {RemoveUpcomingOpening} RemoveUpcomingOpening ++ */ ++ RemoveUpcomingOpening.fromObject = function fromObject(object) { ++ if (object instanceof $root.RemoveUpcomingOpening) ++ return object; ++ var message = new $root.RemoveUpcomingOpening(); ++ if (object.id != null) ++ message.id = String(object.id); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a RemoveUpcomingOpening message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof RemoveUpcomingOpening ++ * @static ++ * @param {RemoveUpcomingOpening} message RemoveUpcomingOpening ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ RemoveUpcomingOpening.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) ++ object.id = ""; ++ if (message.id != null && message.hasOwnProperty("id")) ++ object.id = message.id; ++ return object; ++ }; ++ ++ /** ++ * Converts this RemoveUpcomingOpening to JSON. ++ * @function toJSON ++ * @memberof RemoveUpcomingOpening ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ RemoveUpcomingOpening.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return RemoveUpcomingOpening; ++})(); ++ ++$root.WorkingGroupMetadataAction = (function() { ++ ++ /** ++ * Properties of a WorkingGroupMetadataAction. ++ * @exports IWorkingGroupMetadataAction ++ * @interface IWorkingGroupMetadataAction ++ * @property {ISetGroupMetadata|null} [setGroupMetadata] WorkingGroupMetadataAction setGroupMetadata ++ * @property {IAddUpcomingOpening|null} [addUpcomingOpening] WorkingGroupMetadataAction addUpcomingOpening ++ * @property {IRemoveUpcomingOpening|null} [removeUpcomingOpening] WorkingGroupMetadataAction removeUpcomingOpening ++ */ ++ ++ /** ++ * Constructs a new WorkingGroupMetadataAction. ++ * @exports WorkingGroupMetadataAction ++ * @classdesc Represents a WorkingGroupMetadataAction. ++ * @implements IWorkingGroupMetadataAction ++ * @constructor ++ * @param {IWorkingGroupMetadataAction=} [properties] Properties to set ++ */ ++ function WorkingGroupMetadataAction(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * WorkingGroupMetadataAction setGroupMetadata. ++ * @member {ISetGroupMetadata|null|undefined} setGroupMetadata ++ * @memberof WorkingGroupMetadataAction ++ * @instance ++ */ ++ WorkingGroupMetadataAction.prototype.setGroupMetadata = null; ++ ++ /** ++ * WorkingGroupMetadataAction addUpcomingOpening. ++ * @member {IAddUpcomingOpening|null|undefined} addUpcomingOpening ++ * @memberof WorkingGroupMetadataAction ++ * @instance ++ */ ++ WorkingGroupMetadataAction.prototype.addUpcomingOpening = null; ++ ++ /** ++ * WorkingGroupMetadataAction removeUpcomingOpening. ++ * @member {IRemoveUpcomingOpening|null|undefined} removeUpcomingOpening ++ * @memberof WorkingGroupMetadataAction ++ * @instance ++ */ ++ WorkingGroupMetadataAction.prototype.removeUpcomingOpening = null; ++ ++ // OneOf field names bound to virtual getters and setters ++ var $oneOfFields; ++ ++ /** ++ * WorkingGroupMetadataAction action. ++ * @member {"setGroupMetadata"|"addUpcomingOpening"|"removeUpcomingOpening"|undefined} action ++ * @memberof WorkingGroupMetadataAction ++ * @instance ++ */ ++ Object.defineProperty(WorkingGroupMetadataAction.prototype, "action", { ++ get: $util.oneOfGetter($oneOfFields = ["setGroupMetadata", "addUpcomingOpening", "removeUpcomingOpening"]), ++ set: $util.oneOfSetter($oneOfFields) ++ }); ++ ++ /** ++ * Creates a new WorkingGroupMetadataAction instance using the specified properties. ++ * @function create ++ * @memberof WorkingGroupMetadataAction ++ * @static ++ * @param {IWorkingGroupMetadataAction=} [properties] Properties to set ++ * @returns {WorkingGroupMetadataAction} WorkingGroupMetadataAction instance ++ */ ++ WorkingGroupMetadataAction.create = function create(properties) { ++ return new WorkingGroupMetadataAction(properties); ++ }; ++ ++ /** ++ * Encodes the specified WorkingGroupMetadataAction message. Does not implicitly {@link WorkingGroupMetadataAction.verify|verify} messages. ++ * @function encode ++ * @memberof WorkingGroupMetadataAction ++ * @static ++ * @param {IWorkingGroupMetadataAction} message WorkingGroupMetadataAction message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ WorkingGroupMetadataAction.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.setGroupMetadata != null && Object.hasOwnProperty.call(message, "setGroupMetadata")) ++ $root.SetGroupMetadata.encode(message.setGroupMetadata, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); ++ if (message.addUpcomingOpening != null && Object.hasOwnProperty.call(message, "addUpcomingOpening")) ++ $root.AddUpcomingOpening.encode(message.addUpcomingOpening, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); ++ if (message.removeUpcomingOpening != null && Object.hasOwnProperty.call(message, "removeUpcomingOpening")) ++ $root.RemoveUpcomingOpening.encode(message.removeUpcomingOpening, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim(); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified WorkingGroupMetadataAction message, length delimited. Does not implicitly {@link WorkingGroupMetadataAction.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof WorkingGroupMetadataAction ++ * @static ++ * @param {IWorkingGroupMetadataAction} message WorkingGroupMetadataAction message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ WorkingGroupMetadataAction.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a WorkingGroupMetadataAction message from the specified reader or buffer. ++ * @function decode ++ * @memberof WorkingGroupMetadataAction ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {WorkingGroupMetadataAction} WorkingGroupMetadataAction ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ WorkingGroupMetadataAction.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.WorkingGroupMetadataAction(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.setGroupMetadata = $root.SetGroupMetadata.decode(reader, reader.uint32()); ++ break; ++ case 2: ++ message.addUpcomingOpening = $root.AddUpcomingOpening.decode(reader, reader.uint32()); ++ break; ++ case 3: ++ message.removeUpcomingOpening = $root.RemoveUpcomingOpening.decode(reader, reader.uint32()); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a WorkingGroupMetadataAction message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof WorkingGroupMetadataAction ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {WorkingGroupMetadataAction} WorkingGroupMetadataAction ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ WorkingGroupMetadataAction.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a WorkingGroupMetadataAction message. ++ * @function verify ++ * @memberof WorkingGroupMetadataAction ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ WorkingGroupMetadataAction.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ var properties = {}; ++ if (message.setGroupMetadata != null && message.hasOwnProperty("setGroupMetadata")) { ++ properties.action = 1; ++ { ++ var error = $root.SetGroupMetadata.verify(message.setGroupMetadata); ++ if (error) ++ return "setGroupMetadata." + error; ++ } ++ } ++ if (message.addUpcomingOpening != null && message.hasOwnProperty("addUpcomingOpening")) { ++ if (properties.action === 1) ++ return "action: multiple values"; ++ properties.action = 1; ++ { ++ var error = $root.AddUpcomingOpening.verify(message.addUpcomingOpening); ++ if (error) ++ return "addUpcomingOpening." + error; ++ } ++ } ++ if (message.removeUpcomingOpening != null && message.hasOwnProperty("removeUpcomingOpening")) { ++ if (properties.action === 1) ++ return "action: multiple values"; ++ properties.action = 1; ++ { ++ var error = $root.RemoveUpcomingOpening.verify(message.removeUpcomingOpening); ++ if (error) ++ return "removeUpcomingOpening." + error; ++ } ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates a WorkingGroupMetadataAction message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof WorkingGroupMetadataAction ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {WorkingGroupMetadataAction} WorkingGroupMetadataAction ++ */ ++ WorkingGroupMetadataAction.fromObject = function fromObject(object) { ++ if (object instanceof $root.WorkingGroupMetadataAction) ++ return object; ++ var message = new $root.WorkingGroupMetadataAction(); ++ if (object.setGroupMetadata != null) { ++ if (typeof object.setGroupMetadata !== "object") ++ throw TypeError(".WorkingGroupMetadataAction.setGroupMetadata: object expected"); ++ message.setGroupMetadata = $root.SetGroupMetadata.fromObject(object.setGroupMetadata); ++ } ++ if (object.addUpcomingOpening != null) { ++ if (typeof object.addUpcomingOpening !== "object") ++ throw TypeError(".WorkingGroupMetadataAction.addUpcomingOpening: object expected"); ++ message.addUpcomingOpening = $root.AddUpcomingOpening.fromObject(object.addUpcomingOpening); ++ } ++ if (object.removeUpcomingOpening != null) { ++ if (typeof object.removeUpcomingOpening !== "object") ++ throw TypeError(".WorkingGroupMetadataAction.removeUpcomingOpening: object expected"); ++ message.removeUpcomingOpening = $root.RemoveUpcomingOpening.fromObject(object.removeUpcomingOpening); ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a WorkingGroupMetadataAction message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof WorkingGroupMetadataAction ++ * @static ++ * @param {WorkingGroupMetadataAction} message WorkingGroupMetadataAction ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ WorkingGroupMetadataAction.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (message.setGroupMetadata != null && message.hasOwnProperty("setGroupMetadata")) { ++ object.setGroupMetadata = $root.SetGroupMetadata.toObject(message.setGroupMetadata, options); ++ if (options.oneofs) ++ object.action = "setGroupMetadata"; ++ } ++ if (message.addUpcomingOpening != null && message.hasOwnProperty("addUpcomingOpening")) { ++ object.addUpcomingOpening = $root.AddUpcomingOpening.toObject(message.addUpcomingOpening, options); ++ if (options.oneofs) ++ object.action = "addUpcomingOpening"; ++ } ++ if (message.removeUpcomingOpening != null && message.hasOwnProperty("removeUpcomingOpening")) { ++ object.removeUpcomingOpening = $root.RemoveUpcomingOpening.toObject(message.removeUpcomingOpening, options); ++ if (options.oneofs) ++ object.action = "removeUpcomingOpening"; ++ } ++ return object; ++ }; ++ ++ /** ++ * Converts this WorkingGroupMetadataAction to JSON. ++ * @function toJSON ++ * @memberof WorkingGroupMetadataAction ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ WorkingGroupMetadataAction.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return WorkingGroupMetadataAction; ++})(); ++ ++$root.ModeratePost = (function() { ++ ++ /** ++ * Properties of a ModeratePost. ++ * @exports IModeratePost ++ * @interface IModeratePost ++ * @property {Long} postId ModeratePost postId ++ * @property {string} rationale ModeratePost rationale ++ */ ++ ++ /** ++ * Constructs a new ModeratePost. ++ * @exports ModeratePost ++ * @classdesc Represents a ModeratePost. ++ * @implements IModeratePost ++ * @constructor ++ * @param {IModeratePost=} [properties] Properties to set ++ */ ++ function ModeratePost(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * ModeratePost postId. ++ * @member {Long} postId ++ * @memberof ModeratePost ++ * @instance ++ */ ++ ModeratePost.prototype.postId = $util.Long ? $util.Long.fromBits(0,0,true) : 0; ++ ++ /** ++ * ModeratePost rationale. ++ * @member {string} rationale ++ * @memberof ModeratePost ++ * @instance ++ */ ++ ModeratePost.prototype.rationale = ""; ++ ++ /** ++ * Creates a new ModeratePost instance using the specified properties. ++ * @function create ++ * @memberof ModeratePost ++ * @static ++ * @param {IModeratePost=} [properties] Properties to set ++ * @returns {ModeratePost} ModeratePost instance ++ */ ++ ModeratePost.create = function create(properties) { ++ return new ModeratePost(properties); ++ }; ++ ++ /** ++ * Encodes the specified ModeratePost message. Does not implicitly {@link ModeratePost.verify|verify} messages. ++ * @function encode ++ * @memberof ModeratePost ++ * @static ++ * @param {IModeratePost} message ModeratePost message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ModeratePost.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.postId); ++ writer.uint32(/* id 2, wireType 2 =*/18).string(message.rationale); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified ModeratePost message, length delimited. Does not implicitly {@link ModeratePost.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof ModeratePost ++ * @static ++ * @param {IModeratePost} message ModeratePost message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ ModeratePost.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a ModeratePost message from the specified reader or buffer. ++ * @function decode ++ * @memberof ModeratePost ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {ModeratePost} ModeratePost ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ModeratePost.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ModeratePost(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.postId = reader.uint64(); ++ break; ++ case 2: ++ message.rationale = reader.string(); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ if (!message.hasOwnProperty("postId")) ++ throw $util.ProtocolError("missing required 'postId'", { instance: message }); ++ if (!message.hasOwnProperty("rationale")) ++ throw $util.ProtocolError("missing required 'rationale'", { instance: message }); ++ return message; ++ }; ++ ++ /** ++ * Decodes a ModeratePost message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof ModeratePost ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {ModeratePost} ModeratePost ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ ModeratePost.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a ModeratePost message. ++ * @function verify ++ * @memberof ModeratePost ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ ModeratePost.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ if (!$util.isInteger(message.postId) && !(message.postId && $util.isInteger(message.postId.low) && $util.isInteger(message.postId.high))) ++ return "postId: integer|Long expected"; ++ if (!$util.isString(message.rationale)) ++ return "rationale: string expected"; ++ return null; ++ }; ++ ++ /** ++ * Creates a ModeratePost message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof ModeratePost ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {ModeratePost} ModeratePost ++ */ ++ ModeratePost.fromObject = function fromObject(object) { ++ if (object instanceof $root.ModeratePost) ++ return object; ++ var message = new $root.ModeratePost(); ++ if (object.postId != null) ++ if ($util.Long) ++ (message.postId = $util.Long.fromValue(object.postId)).unsigned = true; ++ else if (typeof object.postId === "string") ++ message.postId = parseInt(object.postId, 10); ++ else if (typeof object.postId === "number") ++ message.postId = object.postId; ++ else if (typeof object.postId === "object") ++ message.postId = new $util.LongBits(object.postId.low >>> 0, object.postId.high >>> 0).toNumber(true); ++ if (object.rationale != null) ++ message.rationale = String(object.rationale); ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a ModeratePost message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof ModeratePost ++ * @static ++ * @param {ModeratePost} message ModeratePost ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ ModeratePost.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (options.defaults) { ++ if ($util.Long) { ++ var long = new $util.Long(0, 0, true); ++ object.postId = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; ++ } else ++ object.postId = options.longs === String ? "0" : 0; ++ object.rationale = ""; ++ } ++ if (message.postId != null && message.hasOwnProperty("postId")) ++ if (typeof message.postId === "number") ++ object.postId = options.longs === String ? String(message.postId) : message.postId; ++ else ++ object.postId = options.longs === String ? $util.Long.prototype.toString.call(message.postId) : options.longs === Number ? new $util.LongBits(message.postId.low >>> 0, message.postId.high >>> 0).toNumber(true) : message.postId; ++ if (message.rationale != null && message.hasOwnProperty("rationale")) ++ object.rationale = message.rationale; ++ return object; ++ }; ++ ++ /** ++ * Converts this ModeratePost to JSON. ++ * @function toJSON ++ * @memberof ModeratePost ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ ModeratePost.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return ModeratePost; ++})(); ++ ++$root.RemarkMetadataAction = (function() { ++ ++ /** ++ * Properties of a RemarkMetadataAction. ++ * @exports IRemarkMetadataAction ++ * @interface IRemarkMetadataAction ++ * @property {IModeratePost|null} [moderatePost] RemarkMetadataAction moderatePost ++ */ ++ ++ /** ++ * Constructs a new RemarkMetadataAction. ++ * @exports RemarkMetadataAction ++ * @classdesc Represents a RemarkMetadataAction. ++ * @implements IRemarkMetadataAction ++ * @constructor ++ * @param {IRemarkMetadataAction=} [properties] Properties to set ++ */ ++ function RemarkMetadataAction(properties) { ++ if (properties) ++ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) ++ if (properties[keys[i]] != null) ++ this[keys[i]] = properties[keys[i]]; ++ } ++ ++ /** ++ * RemarkMetadataAction moderatePost. ++ * @member {IModeratePost|null|undefined} moderatePost ++ * @memberof RemarkMetadataAction ++ * @instance ++ */ ++ RemarkMetadataAction.prototype.moderatePost = null; ++ ++ // OneOf field names bound to virtual getters and setters ++ var $oneOfFields; ++ ++ /** ++ * RemarkMetadataAction action. ++ * @member {"moderatePost"|undefined} action ++ * @memberof RemarkMetadataAction ++ * @instance ++ */ ++ Object.defineProperty(RemarkMetadataAction.prototype, "action", { ++ get: $util.oneOfGetter($oneOfFields = ["moderatePost"]), ++ set: $util.oneOfSetter($oneOfFields) ++ }); ++ ++ /** ++ * Creates a new RemarkMetadataAction instance using the specified properties. ++ * @function create ++ * @memberof RemarkMetadataAction ++ * @static ++ * @param {IRemarkMetadataAction=} [properties] Properties to set ++ * @returns {RemarkMetadataAction} RemarkMetadataAction instance ++ */ ++ RemarkMetadataAction.create = function create(properties) { ++ return new RemarkMetadataAction(properties); ++ }; ++ ++ /** ++ * Encodes the specified RemarkMetadataAction message. Does not implicitly {@link RemarkMetadataAction.verify|verify} messages. ++ * @function encode ++ * @memberof RemarkMetadataAction ++ * @static ++ * @param {IRemarkMetadataAction} message RemarkMetadataAction message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ RemarkMetadataAction.encode = function encode(message, writer) { ++ if (!writer) ++ writer = $Writer.create(); ++ if (message.moderatePost != null && Object.hasOwnProperty.call(message, "moderatePost")) ++ $root.ModeratePost.encode(message.moderatePost, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); ++ return writer; ++ }; ++ ++ /** ++ * Encodes the specified RemarkMetadataAction message, length delimited. Does not implicitly {@link RemarkMetadataAction.verify|verify} messages. ++ * @function encodeDelimited ++ * @memberof RemarkMetadataAction ++ * @static ++ * @param {IRemarkMetadataAction} message RemarkMetadataAction message or plain object to encode ++ * @param {$protobuf.Writer} [writer] Writer to encode to ++ * @returns {$protobuf.Writer} Writer ++ */ ++ RemarkMetadataAction.encodeDelimited = function encodeDelimited(message, writer) { ++ return this.encode(message, writer).ldelim(); ++ }; ++ ++ /** ++ * Decodes a RemarkMetadataAction message from the specified reader or buffer. ++ * @function decode ++ * @memberof RemarkMetadataAction ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @param {number} [length] Message length if known beforehand ++ * @returns {RemarkMetadataAction} RemarkMetadataAction ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ RemarkMetadataAction.decode = function decode(reader, length) { ++ if (!(reader instanceof $Reader)) ++ reader = $Reader.create(reader); ++ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.RemarkMetadataAction(); ++ while (reader.pos < end) { ++ var tag = reader.uint32(); ++ switch (tag >>> 3) { ++ case 1: ++ message.moderatePost = $root.ModeratePost.decode(reader, reader.uint32()); ++ break; ++ default: ++ reader.skipType(tag & 7); ++ break; ++ } ++ } ++ return message; ++ }; ++ ++ /** ++ * Decodes a RemarkMetadataAction message from the specified reader or buffer, length delimited. ++ * @function decodeDelimited ++ * @memberof RemarkMetadataAction ++ * @static ++ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from ++ * @returns {RemarkMetadataAction} RemarkMetadataAction ++ * @throws {Error} If the payload is not a reader or valid buffer ++ * @throws {$protobuf.util.ProtocolError} If required fields are missing ++ */ ++ RemarkMetadataAction.decodeDelimited = function decodeDelimited(reader) { ++ if (!(reader instanceof $Reader)) ++ reader = new $Reader(reader); ++ return this.decode(reader, reader.uint32()); ++ }; ++ ++ /** ++ * Verifies a RemarkMetadataAction message. ++ * @function verify ++ * @memberof RemarkMetadataAction ++ * @static ++ * @param {Object.} message Plain object to verify ++ * @returns {string|null} `null` if valid, otherwise the reason why it is not ++ */ ++ RemarkMetadataAction.verify = function verify(message) { ++ if (typeof message !== "object" || message === null) ++ return "object expected"; ++ var properties = {}; ++ if (message.moderatePost != null && message.hasOwnProperty("moderatePost")) { ++ properties.action = 1; ++ { ++ var error = $root.ModeratePost.verify(message.moderatePost); ++ if (error) ++ return "moderatePost." + error; ++ } ++ } ++ return null; ++ }; ++ ++ /** ++ * Creates a RemarkMetadataAction message from a plain object. Also converts values to their respective internal types. ++ * @function fromObject ++ * @memberof RemarkMetadataAction ++ * @static ++ * @param {Object.} object Plain object ++ * @returns {RemarkMetadataAction} RemarkMetadataAction ++ */ ++ RemarkMetadataAction.fromObject = function fromObject(object) { ++ if (object instanceof $root.RemarkMetadataAction) ++ return object; ++ var message = new $root.RemarkMetadataAction(); ++ if (object.moderatePost != null) { ++ if (typeof object.moderatePost !== "object") ++ throw TypeError(".RemarkMetadataAction.moderatePost: object expected"); ++ message.moderatePost = $root.ModeratePost.fromObject(object.moderatePost); ++ } ++ return message; ++ }; ++ ++ /** ++ * Creates a plain object from a RemarkMetadataAction message. Also converts values to other types if specified. ++ * @function toObject ++ * @memberof RemarkMetadataAction ++ * @static ++ * @param {RemarkMetadataAction} message RemarkMetadataAction ++ * @param {$protobuf.IConversionOptions} [options] Conversion options ++ * @returns {Object.} Plain object ++ */ ++ RemarkMetadataAction.toObject = function toObject(message, options) { ++ if (!options) ++ options = {}; ++ var object = {}; ++ if (message.moderatePost != null && message.hasOwnProperty("moderatePost")) { ++ object.moderatePost = $root.ModeratePost.toObject(message.moderatePost, options); ++ if (options.oneofs) ++ object.action = "moderatePost"; ++ } ++ return object; ++ }; ++ ++ /** ++ * Converts this RemarkMetadataAction to JSON. ++ * @function toJSON ++ * @memberof RemarkMetadataAction ++ * @instance ++ * @returns {Object.} JSON object ++ */ ++ RemarkMetadataAction.prototype.toJSON = function toJSON() { ++ return this.constructor.toObject(this, $protobuf.util.toJSONOptions); ++ }; ++ ++ return RemarkMetadataAction; ++})(); ++ ++module.exports = $root; +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/doc-appendix.md b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/doc-appendix.md +new file mode 100644 +index 0000000..b07cf18 +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/doc-appendix.md +@@ -0,0 +1,41 @@ ++ ++ ++## Referencing Assets ++ ++ ++Applications that process messages that contain a `uint32` field that references an asset such as a cover photo or video, should interpret this value as a zero based index into an array/vector that is received external (out of band) to the protobuf message. ++ ++Example in context of query-node processing the runtime event `VideoCreated` ++ ++```rust ++// Runtime event associated with creating a Video ++VideoCreated(video_id: VideoId, video: Video, assets: Vec, params: VideoCreationParameters) ++ ++struct VideoCreationParameters { ++ in_category: VideoCategoryId, ++ // binary serialized VideoMetadata protobuf message ++ meta: Vec, ++} ++ ++// suppose assets is a vector of two elements. This is the "out of band" array being referenced by the VideoMetadata message ++assets = [ ++ NewAsset::Uri("https://mydomain.net/thumbnail.png"), ++ NewAsset::Upload({ ++ content_id, ++ ipfs_hash, ++ size, ++ ... ++ }), ++]; ++ ++meta = VideoMetadata { ++ ... ++ // refers to second element: assets[1] which is being uploaded to the storage system ++ video: 1, ++ // refers to the first element assets[0] which is being referneced by a url string. ++ thumbnail_photo: 0, ++ ... ++}; ++``` +\ No newline at end of file +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/doc/index.md b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/doc/index.md +new file mode 100644 +index 0000000..c3f7795 +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/doc/index.md +@@ -0,0 +1,1396 @@ ++# Protocol Documentation ++ ++ ++## Table of Contents ++ ++- [proto/Bounty.proto](#proto/Bounty.proto) ++ - [BountyMetadata](#.BountyMetadata) ++ - [BountyWorkData](#.BountyWorkData) ++ ++- [proto/Channel.proto](#proto/Channel.proto) ++ - [ChannelMetadata](#.ChannelMetadata) ++ ++- [proto/ChannelPayouts.proto](#proto/ChannelPayouts.proto) ++ - [ChannelPayoutsMetadata](#.ChannelPayoutsMetadata) ++ - [ChannelPayoutsMetadata.Body](#.ChannelPayoutsMetadata.Body) ++ - [ChannelPayoutsMetadata.Body.ChannelPayoutProof](#.ChannelPayoutsMetadata.Body.ChannelPayoutProof) ++ - [ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement](#.ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement) ++ - [ChannelPayoutsMetadata.Header](#.ChannelPayoutsMetadata.Header) ++ - [ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset](#.ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset) ++ ++ - [ChannelPayoutsMetadata.Body.ChannelPayoutProof.Side](#.ChannelPayoutsMetadata.Body.ChannelPayoutProof.Side) ++ ++- [proto/Council.proto](#proto/Council.proto) ++ - [CouncilCandidacyNoteMetadata](#.CouncilCandidacyNoteMetadata) ++ ++- [proto/Forum.proto](#proto/Forum.proto) ++ - [ForumPostMetadata](#.ForumPostMetadata) ++ - [ForumThreadMetadata](#.ForumThreadMetadata) ++ ++- [proto/Membership.proto](#proto/Membership.proto) ++ - [MembershipMetadata](#.MembershipMetadata) ++ - [MembershipMetadata.ExternalResource](#.MembershipMetadata.ExternalResource) ++ ++ - [MembershipMetadata.ExternalResource.ResourceType](#.MembershipMetadata.ExternalResource.ResourceType) ++ ++- [proto/Metaprotocol.proto](#proto/Metaprotocol.proto) ++ - [BanOrUnbanMemberFromChannel](#.BanOrUnbanMemberFromChannel) ++ - [ChannelModeratorRemarked](#.ChannelModeratorRemarked) ++ - [ChannelOwnerRemarked](#.ChannelOwnerRemarked) ++ - [CreateComment](#.CreateComment) ++ - [CreateVideoCategory](#.CreateVideoCategory) ++ - [DeleteComment](#.DeleteComment) ++ - [EditComment](#.EditComment) ++ - [MakeChannelPayment](#.MakeChannelPayment) ++ - [MemberRemarked](#.MemberRemarked) ++ - [ModerateComment](#.ModerateComment) ++ - [PinOrUnpinComment](#.PinOrUnpinComment) ++ - [ReactComment](#.ReactComment) ++ - [ReactVideo](#.ReactVideo) ++ - [VideoReactionsPreference](#.VideoReactionsPreference) ++ ++ - [BanOrUnbanMemberFromChannel.Option](#.BanOrUnbanMemberFromChannel.Option) ++ - [PinOrUnpinComment.Option](#.PinOrUnpinComment.Option) ++ - [ReactVideo.Reaction](#.ReactVideo.Reaction) ++ - [VideoReactionsPreference.Option](#.VideoReactionsPreference.Option) ++ ++- [proto/Person.proto](#proto/Person.proto) ++ - [PersonMetadata](#.PersonMetadata) ++ ++- [proto/ProposalsDiscussion.proto](#proto/ProposalsDiscussion.proto) ++ - [ProposalsDiscussionPostMetadata](#.ProposalsDiscussionPostMetadata) ++ ++- [proto/Series.proto](#proto/Series.proto) ++ - [SeasonMetadata](#.SeasonMetadata) ++ - [SeriesMetadata](#.SeriesMetadata) ++ ++- [proto/Storage.proto](#proto/Storage.proto) ++ - [DistributionBucketFamilyMetadata](#.DistributionBucketFamilyMetadata) ++ - [DistributionBucketOperatorMetadata](#.DistributionBucketOperatorMetadata) ++ - [GeoCoordiantes](#.GeoCoordiantes) ++ - [GeographicalArea](#.GeographicalArea) ++ - [NodeLocationMetadata](#.NodeLocationMetadata) ++ - [StorageBucketOperatorMetadata](#.StorageBucketOperatorMetadata) ++ ++ - [GeographicalArea.Continent](#.GeographicalArea.Continent) ++ ++- [proto/Video.proto](#proto/Video.proto) ++ - [ContentMetadata](#.ContentMetadata) ++ - [License](#.License) ++ - [MediaType](#.MediaType) ++ - [PublishedBeforeJoystream](#.PublishedBeforeJoystream) ++ - [SubtitleMetadata](#.SubtitleMetadata) ++ - [VideoMetadata](#.VideoMetadata) ++ ++- [proto/WorkingGroups.proto](#proto/WorkingGroups.proto) ++ - [AddUpcomingOpening](#.AddUpcomingOpening) ++ - [ApplicationMetadata](#.ApplicationMetadata) ++ - [OpeningMetadata](#.OpeningMetadata) ++ - [OpeningMetadata.ApplicationFormQuestion](#.OpeningMetadata.ApplicationFormQuestion) ++ - [RemoveUpcomingOpening](#.RemoveUpcomingOpening) ++ - [SetGroupMetadata](#.SetGroupMetadata) ++ - [UpcomingOpeningMetadata](#.UpcomingOpeningMetadata) ++ - [WorkingGroupMetadata](#.WorkingGroupMetadata) ++ - [WorkingGroupMetadataAction](#.WorkingGroupMetadataAction) ++ ++ - [OpeningMetadata.ApplicationFormQuestion.InputType](#.OpeningMetadata.ApplicationFormQuestion.InputType) ++ ++- [Scalar Value Types](#scalar-value-types) ++ ++ ++ ++ ++

Top

++ ++## proto/Bounty.proto ++ ++ ++ ++ ++ ++### BountyMetadata ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| title | [string](#string) | optional | Bounty title | ++| description | [string](#string) | optional | Bounty description | ++| discussionThread | [uint64](#uint64) | optional | Id of the forum thread used to discuss the bounty | ++| banner_image_uri | [string](#string) | optional | Image uri of the bounty's banner | ++ ++ ++ ++ ++ ++ ++ ++ ++### BountyWorkData ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| title | [string](#string) | optional | Title of the work | ++| description | [string](#string) | optional | Description which contains the work itself as a URL, a BLOB, or just text | ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++

Top

++ ++## proto/Channel.proto ++ ++ ++ ++ ++ ++### ChannelMetadata ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| title | [string](#string) | optional | Channel Title | ++| description | [string](#string) | optional | Channel Description | ++| is_public | [bool](#bool) | optional | Wether to display channel to the public | ++| language | [string](#string) | optional | ISO_639-1 Language [Code](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) | ++| cover_photo | [uint32](#uint32) | optional | index into external [assets array](#.Assets) | ++| avatar_photo | [uint32](#uint32) | optional | index into external [assets array](#.Assets) | ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++

Top

++ ++## proto/ChannelPayouts.proto ++ ++ ++ ++ ++ ++### ChannelPayoutsMetadata ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| header | [ChannelPayoutsMetadata.Header](#ChannelPayoutsMetadata.Header) | required | Payload header | ++| body | [ChannelPayoutsMetadata.Body](#ChannelPayoutsMetadata.Body) | required | Payload body | ++ ++ ++ ++ ++ ++ ++ ++ ++### ChannelPayoutsMetadata.Body ++Channel payout full body structure, it will not be downloaded by clients in full ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| channel_payouts | [ChannelPayoutsMetadata.Body.ChannelPayoutProof](#ChannelPayoutsMetadata.Body.ChannelPayoutProof) | repeated | List of channel payouts | ++ ++ ++ ++ ++ ++ ++ ++ ++### ChannelPayoutsMetadata.Body.ChannelPayoutProof ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| channel_id | [uint32](#uint32) | required | | ++| cumulative_reward_earned | [string](#string) | required | Since protobuf does not support 128 bit unsigned inetgers so string representation is being used here, after message decoding the string would be converted to BN to pervent precision loss | ++| merkle_branch | [ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement](#ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement) | repeated | | ++| reason | [string](#string) | required | reward rationale for channel; | ++ ++ ++ ++ ++ ++ ++ ++ ++### ChannelPayoutsMetadata.Body.ChannelPayoutProof.ProofElement ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| hash | [string](#string) | required | | ++| side | [ChannelPayoutsMetadata.Body.ChannelPayoutProof.Side](#ChannelPayoutsMetadata.Body.ChannelPayoutProof.Side) | required | | ++ ++ ++ ++ ++ ++ ++ ++ ++### ChannelPayoutsMetadata.Header ++Fields in the payload header are encoded in fixed length 32/64 bits instead of [varint encoding](https://developers.google.com/protocol-buffers/docs/encoding#varints) (uint64/32). ++This allows first calculating, and then setting the byte offset of each `ChannelPayoutProof` accurately, e.g. ++`byte_offset` = `size(Header)` + `position_where_record_for_channel_exists_in_Body` ++If varint encoding is used for header fields, then calculating the byte offset of `ChannelPayoutProof` ++w.r.t the start of the payload would be improbable since the header size won't be known. ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| payload_length_in_bytes | [fixed64](#fixed64) | required | Length in bytes of entire payload | ++| header_length_in_bytes | [fixed64](#fixed64) | required | Length in bytes of payload header | ++| number_of_channels | [fixed32](#fixed32) | required | Number of channels | ++| channel_payout_byte_offsets | [ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset](#ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset) | repeated | List of byte offsets for all channels | ++ ++ ++ ++ ++ ++ ++ ++ ++### ChannelPayoutsMetadata.Header.ChannelPayoutByteOffset ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| channel_id | [fixed32](#fixed32) | required | Channel id | ++| byte_offset | [fixed64](#fixed64) | required | Byte offset from start of payload where payout record for given channel Id exists | ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++### ChannelPayoutsMetadata.Body.ChannelPayoutProof.Side ++ ++ ++| Name | Number | Description | ++| ---- | ------ | ----------- | ++| Left | 0 | | ++| Right | 1 | | ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++

Top

++ ++## proto/Council.proto ++ ++ ++ ++ ++ ++### CouncilCandidacyNoteMetadata ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| header | [string](#string) | optional | Candidacy header text | ++| bullet_points | [string](#string) | repeated | Candidate program in form of bullet points | ++| banner_image_uri | [string](#string) | optional | Image uri of candidate's banner | ++| description | [string](#string) | optional | Candidacy description (md-formatted) | ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++

Top

++ ++## proto/Forum.proto ++ ++ ++ ++ ++ ++### ForumPostMetadata ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| text | [string](#string) | optional | Post text content (md-formatted) | ++| repliesTo | [uint32](#uint32) | optional | Id of the post that given post replies to (if any) | ++ ++ ++ ++ ++ ++ ++ ++ ++### ForumThreadMetadata ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| title | [string](#string) | optional | Thread title | ++| tags | [string](#string) | repeated | Tags accociated with the thread. Any update overrides all current tags. Only the first {MAX_TAGS_PER_FORUM_THREAD} (const exposed via @joystream/metadata-protobuf/consts) tags are taken into account. In order to unset current tags, [''] (array with empty string) must be provided as value. | ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++

Top

++ ++## proto/Membership.proto ++ ++ ++ ++ ++ ++### MembershipMetadata ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| name | [string](#string) | optional | Member's real name | ++| avatar_object | [uint32](#uint32) | optional | Member's avatar - index into external [assets array](#.Assets) | ++| avatar_uri | [string](#string) | optional | Url to member's avatar | ++| about | [string](#string) | optional | Member's md-formatted about text | ++| externalResources | [MembershipMetadata.ExternalResource](#MembershipMetadata.ExternalResource) | repeated | | ++ ++ ++ ++ ++ ++ ++ ++ ++### MembershipMetadata.ExternalResource ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| type | [MembershipMetadata.ExternalResource.ResourceType](#MembershipMetadata.ExternalResource.ResourceType) | optional | | ++| value | [string](#string) | optional | | ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++### MembershipMetadata.ExternalResource.ResourceType ++ ++ ++| Name | Number | Description | ++| ---- | ------ | ----------- | ++| EMAIL | 0 | | ++| HYPERLINK | 1 | | ++| TWITTER | 2 | | ++| TELEGRAM | 3 | | ++| DISCORD | 4 | | ++| FACEBOOK | 5 | | ++| YOUTUBE | 6 | | ++| MATRIX | 7 | | ++| IRC | 8 | | ++| WECHAT | 9 | | ++| WHATSAPP | 10 | | ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++

Top

++ ++## proto/Metaprotocol.proto ++ ++ ++ ++ ++ ++### BanOrUnbanMemberFromChannel ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| member_id | [uint64](#uint64) | required | ID of the member that channel owner wants to ban from participating on any video. | ++| option | [BanOrUnbanMemberFromChannel.Option](#BanOrUnbanMemberFromChannel.Option) | required | Selected option to ban or unban member from the channel | ++ ++ ++ ++ ++ ++ ++ ++ ++### ChannelModeratorRemarked ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| moderate_comment | [ModerateComment](#ModerateComment) | optional | | ++ ++ ++ ++ ++ ++ ++ ++ ++### ChannelOwnerRemarked ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| pin_or_unpin_comment | [PinOrUnpinComment](#PinOrUnpinComment) | optional | | ++| ban_or_unban_member_from_channel | [BanOrUnbanMemberFromChannel](#BanOrUnbanMemberFromChannel) | optional | | ++| video_reactions_preference | [VideoReactionsPreference](#VideoReactionsPreference) | optional | | ++| moderate_comment | [ModerateComment](#ModerateComment) | optional | | ++ ++ ++ ++ ++ ++ ++ ++ ++### CreateComment ++create comment ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| video_id | [uint64](#uint64) | required | ID of the video | ++| parent_comment_id | [string](#string) | optional | ID of comment member wants to reply (empty if new comment is parent comment) | ++| body | [string](#string) | required | Comment text | ++ ++ ++ ++ ++ ++ ++ ++ ++### CreateVideoCategory ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| name | [string](#string) | required | | ++| description | [string](#string) | optional | | ++| parent_category_id | [string](#string) | optional | | ++ ++ ++ ++ ++ ++ ++ ++ ++### DeleteComment ++delete comment by author ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| comment_id | [string](#string) | required | ID of the comment which will be deleted | ++ ++ ++ ++ ++ ++ ++ ++ ++### EditComment ++edit comment by author ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| comment_id | [string](#string) | required | ID of the comment whose text is being edited | ++| new_body | [string](#string) | required | New comment body | ++ ++ ++ ++ ++ ++ ++ ++ ++### MakeChannelPayment ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| rationale | [string](#string) | optional | Reason why payment is being made | ++| video_id | [uint64](#uint64) | optional | | ++| channel_id | [uint64](#uint64) | optional | | ++ ++ ++ ++ ++ ++ ++ ++ ++### MemberRemarked ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| react_video | [ReactVideo](#ReactVideo) | optional | | ++| react_comment | [ReactComment](#ReactComment) | optional | | ++| create_comment | [CreateComment](#CreateComment) | optional | | ++| edit_comment | [EditComment](#EditComment) | optional | | ++| delete_comment | [DeleteComment](#DeleteComment) | optional | | ++| create_video_category | [CreateVideoCategory](#CreateVideoCategory) | optional | | ++| make_channel_payment | [MakeChannelPayment](#MakeChannelPayment) | optional | | ++ ++ ++ ++ ++ ++ ++ ++ ++### ModerateComment ++delete comment by moderator or channel owner; ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| comment_id | [string](#string) | required | ID of comment that will be deleted by moderator | ++| rationale | [string](#string) | required | why moderator wants to delete this comment | ++ ++ ++ ++ ++ ++ ++ ++ ++### PinOrUnpinComment ++pin comment on a video by channel owner ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| video_id | [uint64](#uint64) | required | ID of the video | ++| comment_id | [string](#string) | required | ID of the comment which will be pinned | ++| option | [PinOrUnpinComment.Option](#PinOrUnpinComment.Option) | required | Selected option to pin or unpin comment from channel | ++ ++ ++ ++ ++ ++ ++ ++ ++### ReactComment ++reacting, unreacting to a comment ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| comment_id | [string](#string) | required | ID of the comment to react | ++| reaction_id | [uint32](#uint32) | required | ID of the selected reaction | ++ ++ ++ ++ ++ ++ ++ ++ ++### ReactVideo ++reacting, unreacting, and changing reaction to video ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| video_id | [uint64](#uint64) | required | ID of the video to react | ++| reaction | [ReactVideo.Reaction](#ReactVideo.Reaction) | required | Selected reaction | ++ ++ ++ ++ ++ ++ ++ ++ ++### VideoReactionsPreference ++Enable or disable reactions on a single video ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| video_id | [uint64](#uint64) | required | ID of the video | ++| option | [VideoReactionsPreference.Option](#VideoReactionsPreference.Option) | required | Selected option to enable or disable comment section | ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++### BanOrUnbanMemberFromChannel.Option ++ ++ ++| Name | Number | Description | ++| ---- | ------ | ----------- | ++| BAN | 0 | Ban member (nothing happens if member is already banned) | ++| UNBAN | 1 | Unban member (nothing happens if member is already unbanned) | ++ ++ ++ ++ ++ ++### PinOrUnpinComment.Option ++ ++ ++| Name | Number | Description | ++| ---- | ------ | ----------- | ++| PIN | 0 | Pin comment on video (nothing happens if comment is already pinned) | ++| UNPIN | 1 | Unpin comment from video (nothing happens if comment is already unpinned) | ++ ++ ++ ++ ++ ++### ReactVideo.Reaction ++The enum must be wrapped inside "message", otherwide it breaks protobufjs ++Reacting again with the same message option will cancel the previous reaction ++ ++| Name | Number | Description | ++| ---- | ------ | ----------- | ++| LIKE | 0 | | ++| UNLIKE | 1 | | ++ ++ ++ ++ ++ ++### VideoReactionsPreference.Option ++ ++ ++| Name | Number | Description | ++| ---- | ------ | ----------- | ++| ENABLE | 0 | Enable reactions (nothing happens if they are already enabled) | ++| DISABLE | 1 | Disable reactions (nothing happens if they are already disabled) | ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++

Top

++ ++## proto/Person.proto ++ ++ ++ ++ ++ ++### PersonMetadata ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| first_name | [string](#string) | optional | | ++| middle_name | [string](#string) | optional | | ++| last_name | [string](#string) | optional | | ++| about | [string](#string) | optional | | ++| cover_photo | [uint32](#uint32) | optional | index into external [assets array](#.Assets) | ++| avatar_photo | [uint32](#uint32) | optional | index into external [assets array](#.Assets) | ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++

Top

++ ++## proto/ProposalsDiscussion.proto ++ ++ ++ ++ ++ ++### ProposalsDiscussionPostMetadata ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| text | [string](#string) | optional | Post text content (md-formatted) | ++| repliesTo | [uint32](#uint32) | optional | Id of the post that given post replies to (if any) | ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++

Top

++ ++## proto/Series.proto ++ ++ ++ ++ ++ ++### SeasonMetadata ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| title | [string](#string) | optional | | ++| description | [string](#string) | optional | | ++| cover_photo | [uint32](#uint32) | optional | index into external [assets array](#.Assets) | ++| persons | [uint64](#uint64) | repeated | Person(s) referenced by PersonId involved in this Season | ++ ++ ++ ++ ++ ++ ++ ++ ++### SeriesMetadata ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| title | [string](#string) | optional | | ++| description | [string](#string) | optional | | ++| cover_photo | [uint32](#uint32) | optional | index into external [assets array](#.Assets) | ++| persons | [uint64](#uint64) | repeated | Person(s) referenced by PersonId involved in this Series | ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++

Top

++ ++## proto/Storage.proto ++ ++ ++ ++ ++ ++### DistributionBucketFamilyMetadata ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| region | [string](#string) | optional | ID / name of the region covered by the distribution family (ie. us-east-1). Should be unique. | ++| description | [string](#string) | optional | Additional, more specific description of the region | ++| areas | [GeographicalArea](#GeographicalArea) | repeated | Standarized geographical areas covered by the family (providing [{}] will unset the current value) | ++| latency_test_targets | [string](#string) | repeated | List of targets (hosts/ips) best suited latency measurements for this family | ++ ++ ++ ++ ++ ++ ++ ++ ++### DistributionBucketOperatorMetadata ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| endpoint | [string](#string) | optional | Root distribution node endpoint (ie. https://example.com/distribution) | ++| location | [NodeLocationMetadata](#NodeLocationMetadata) | optional | Information about node's phisical location (providing {} will unset current value) | ++| extra | [string](#string) | optional | Additional information about the node / node operator | ++ ++ ++ ++ ++ ++ ++ ++ ++### GeoCoordiantes ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| latitude | [float](#float) | optional | | ++| longitude | [float](#float) | optional | | ++ ++ ++ ++ ++ ++ ++ ++ ++### GeographicalArea ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| continent | [GeographicalArea.Continent](#GeographicalArea.Continent) | optional | | ++| country_code | [string](#string) | optional | ISO 3166-1 alpha-2 country code | ++| subdivision_code | [string](#string) | optional | ISO 3166-2 subdivision code | ++ ++ ++ ++ ++ ++ ++ ++ ++### NodeLocationMetadata ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| country_code | [string](#string) | optional | ISO 3166-1 alpha-2 country code (2 letters) | ++| city | [string](#string) | optional | City name | ++| coordinates | [GeoCoordiantes](#GeoCoordiantes) | optional | Geographic coordinates (providing {} will unset current value) | ++ ++ ++ ++ ++ ++ ++ ++ ++### StorageBucketOperatorMetadata ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| endpoint | [string](#string) | optional | Root storage node endpoint (ie. https://example.com/storage) | ++| location | [NodeLocationMetadata](#NodeLocationMetadata) | optional | Information about node's phisical location (providing {} will unset current value) | ++| extra | [string](#string) | optional | Additional information about the node / node operator | ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++### GeographicalArea.Continent ++ ++ ++| Name | Number | Description | ++| ---- | ------ | ----------- | ++| AF | 1 | | ++| NA | 2 | | ++| OC | 3 | | ++| AN | 4 | | ++| AS | 5 | | ++| EU | 6 | | ++| SA | 7 | | ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++

Top

++ ++## proto/Video.proto ++ ++ ++ ++ ++ ++### ContentMetadata ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| video_metadata | [VideoMetadata](#VideoMetadata) | optional | ... Other possible metadata standards, e.g. `PlaylistMetadata` | ++ ++ ++ ++ ++ ++ ++ ++ ++### License ++License types defined by Joystream ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| code | [uint32](#uint32) | optional | License code defined by Joystream. [reference](../src/KnownLicenses.json) | ++| attribution | [string](#string) | optional | Text for licenses that require an attribution | ++| custom_text | [string](#string) | optional | Text for custom license type | ++ ++ ++ ++ ++ ++ ++ ++ ++### MediaType ++Codec, Container, MIME media-type information ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| codec_name | [string](#string) | optional | Codec corresponding to `name` field from [FFmpeg](https://github.com/FFmpeg/FFmpeg/blob/master/libavcodec/codec_desc.c) | ++| container | [string](#string) | optional | Video container format, eg. 'MP4', 'WebM', 'Ogg' [ref](https://developer.mozilla.org/en-US/docs/Web/Media/Formats/Video_codecs) | ++| mime_media_type | [string](#string) | optional | MIME Media Type, eg. 'video/mp4' [ref](https://www.iana.org/assignments/media-types/media-types.xhtml#video) | ++ ++ ++ ++ ++ ++ ++ ++ ++### PublishedBeforeJoystream ++Publication status before joystream ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| is_published | [bool](#bool) | optional | Was video published before joystream platform | ++| date | [string](#string) | optional | Date of publication: 'YYYY-MM-DD' [ISO-8601](https://www.iso.org/iso-8601-date-and-time-format.html) | ++ ++ ++ ++ ++ ++ ++ ++ ++### SubtitleMetadata ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| type | [string](#string) | required | | ++| new_asset | [uint32](#uint32) | optional | index into external [assets array](#.Assets) | ++| language | [string](#string) | required | ISO_639-1 Language [Code](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) | ++| mimeType | [string](#string) | required | | ++ ++ ++ ++ ++ ++ ++ ++ ++### VideoMetadata ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| title | [string](#string) | optional | Video Title | ++| description | [string](#string) | optional | Video Description | ++| video | [uint32](#uint32) | optional | index into external [assets array](#.Assets) | ++| thumbnail_photo | [uint32](#uint32) | optional | index into external [assets array](#.Assets) | ++| duration | [uint32](#uint32) | optional | Lengths of video in seconds | ++| media_pixel_height | [uint32](#uint32) | optional | Resolution of the video (Height) | ++| media_pixel_width | [uint32](#uint32) | optional | Resolution of the video (Width) | ++| media_type | [MediaType](#MediaType) | optional | Encoding and Container format used | ++| language | [string](#string) | optional | ISO_639-1 Language [Code](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) | ++| license | [License](#License) | optional | License type for the media | ++| published_before_joystream | [PublishedBeforeJoystream](#PublishedBeforeJoystream) | optional | Date of publication | ++| has_marketing | [bool](#bool) | optional | Does video have marketing or advertising in the stream | ++| is_public | [bool](#bool) | optional | Should video be publicy visible yet | ++| is_explicit | [bool](#bool) | optional | Does Video have explicit language or scenes | ++| persons | [uint64](#uint64) | repeated | Person(s) referenced by PersonId involved in this video | ++| category | [string](#string) | optional | Video Category Id | ++| subtitles | [SubtitleMetadata](#SubtitleMetadata) | repeated | Video subtitles | ++| enable_comments | [bool](#bool) | optional | Enable/Disable the comment section | ++| clear_subtitles | [bool](#bool) | optional | Remove all subtitles; since protobuf doesn't distinguish b/w empty array and null field, simply removing all subtitles by overriding list with an empty array wont work | ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++

Top

++ ++## proto/WorkingGroups.proto ++ ++ ++ ++ ++ ++### AddUpcomingOpening ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| metadata | [UpcomingOpeningMetadata](#UpcomingOpeningMetadata) | optional | Upcoming opening metadata | ++ ++ ++ ++ ++ ++ ++ ++ ++### ApplicationMetadata ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| answers | [string](#string) | repeated | List of answers to opening application form questions | ++ ++ ++ ++ ++ ++ ++ ++ ++### OpeningMetadata ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| short_description | [string](#string) | optional | Short description of the opening | ++| description | [string](#string) | optional | Full description of the opening | ++| hiring_limit | [uint32](#uint32) | optional | Expected number of hired applicants | ++| expected_ending_timestamp | [uint32](#uint32) | optional | Expected time when the opening will close (Unix timestamp) | ++| application_details | [string](#string) | optional | Md-formatted text explaining the application process | ++| application_form_questions | [OpeningMetadata.ApplicationFormQuestion](#OpeningMetadata.ApplicationFormQuestion) | repeated | List of questions that should be answered during application | ++| title | [string](#string) | optional | | ++ ++ ++ ++ ++ ++ ++ ++ ++### OpeningMetadata.ApplicationFormQuestion ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| question | [string](#string) | optional | The question itself (ie. "What is your name?"") | ++| type | [OpeningMetadata.ApplicationFormQuestion.InputType](#OpeningMetadata.ApplicationFormQuestion.InputType) | optional | Suggested type of the UI answer input | ++ ++ ++ ++ ++ ++ ++ ++ ++### RemoveUpcomingOpening ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| id | [string](#string) | optional | Upcoming opening query-node id | ++ ++ ++ ++ ++ ++ ++ ++ ++### SetGroupMetadata ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| new_metadata | [WorkingGroupMetadata](#WorkingGroupMetadata) | optional | New working group metadata to set (can be a partial update) | ++ ++ ++ ++ ++ ++ ++ ++ ++### UpcomingOpeningMetadata ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| expected_start | [uint32](#uint32) | optional | Expected opening start (timestamp) | ++| reward_per_block | [uint64](#uint64) | optional | Expected reward per block | ++| min_application_stake | [uint64](#uint64) | optional | Expected min. application stake | ++| metadata | [OpeningMetadata](#OpeningMetadata) | optional | Opening metadata | ++ ++ ++ ++ ++ ++ ++ ++ ++### WorkingGroupMetadata ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| description | [string](#string) | optional | Group description text (md-formatted) | ++| about | [string](#string) | optional | Group about text (md-formatted) | ++| status | [string](#string) | optional | Current group status (expected to be 1-3 words) | ++| status_message | [string](#string) | optional | Short status message associated with the status | ++ ++ ++ ++ ++ ++ ++ ++ ++### WorkingGroupMetadataAction ++ ++ ++ ++| Field | Type | Label | Description | ++| ----- | ---- | ----- | ----------- | ++| set_group_metadata | [SetGroupMetadata](#SetGroupMetadata) | optional | | ++| add_upcoming_opening | [AddUpcomingOpening](#AddUpcomingOpening) | optional | | ++| remove_upcoming_opening | [RemoveUpcomingOpening](#RemoveUpcomingOpening) | optional | | ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++### OpeningMetadata.ApplicationFormQuestion.InputType ++ ++ ++| Name | Number | Description | ++| ---- | ------ | ----------- | ++| TEXTAREA | 0 | | ++| TEXT | 1 | | ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++## Scalar Value Types ++ ++| .proto Type | Notes | C++ | Java | Python | Go | C# | PHP | Ruby | ++| ----------- | ----- | --- | ---- | ------ | -- | -- | --- | ---- | ++| double | | double | double | float | float64 | double | float | Float | ++| float | | float | float | float | float32 | float | float | Float | ++| int32 | Uses variable-length encoding. Inefficient for encoding negative numbers – if your field is likely to have negative values, use sint32 instead. | int32 | int | int | int32 | int | integer | Bignum or Fixnum (as required) | ++| int64 | Uses variable-length encoding. Inefficient for encoding negative numbers – if your field is likely to have negative values, use sint64 instead. | int64 | long | int/long | int64 | long | integer/string | Bignum | ++| uint32 | Uses variable-length encoding. | uint32 | int | int/long | uint32 | uint | integer | Bignum or Fixnum (as required) | ++| uint64 | Uses variable-length encoding. | uint64 | long | int/long | uint64 | ulong | integer/string | Bignum or Fixnum (as required) | ++| sint32 | Uses variable-length encoding. Signed int value. These more efficiently encode negative numbers than regular int32s. | int32 | int | int | int32 | int | integer | Bignum or Fixnum (as required) | ++| sint64 | Uses variable-length encoding. Signed int value. These more efficiently encode negative numbers than regular int64s. | int64 | long | int/long | int64 | long | integer/string | Bignum | ++| fixed32 | Always four bytes. More efficient than uint32 if values are often greater than 2^28. | uint32 | int | int | uint32 | uint | integer | Bignum or Fixnum (as required) | ++| fixed64 | Always eight bytes. More efficient than uint64 if values are often greater than 2^56. | uint64 | long | int/long | uint64 | ulong | integer/string | Bignum | ++| sfixed32 | Always four bytes. | int32 | int | int | int32 | int | integer | Bignum or Fixnum (as required) | ++| sfixed64 | Always eight bytes. | int64 | long | int/long | int64 | long | integer/string | Bignum | ++| bool | | bool | boolean | boolean | bool | bool | boolean | TrueClass/FalseClass | ++| string | A string must always contain UTF-8 encoded or 7-bit ASCII text. | string | String | str/unicode | string | string | string | String (UTF-8) | ++| bytes | May contain any arbitrary sequence of bytes. | string | ByteString | str | []byte | ByteString | string | String (ASCII-8BIT) | ++ ++ ++ ++## Referencing Assets ++ ++ ++Applications that process messages that contain a `uint32` field that references an asset such as a cover photo or video, should interpret this value as a zero based index into an array/vector that is received external (out of band) to the protobuf message. ++ ++Example in context of query-node processing the runtime event `VideoCreated` ++ ++```rust ++// Runtime event associated with creating a Video ++VideoCreated(video_id: VideoId, video: Video, assets: Vec, params: VideoCreationParameters) ++ ++struct VideoCreationParameters { ++ in_category: VideoCategoryId, ++ // binary serialized VideoMetadata protobuf message ++ meta: Vec, ++} ++ ++// suppose assets is a vector of two elements. This is the "out of band" array being referenced by the VideoMetadata message ++assets = [ ++ NewAsset::Uri("https://mydomain.net/thumbnail.png"), ++ NewAsset::Upload({ ++ content_id, ++ ipfs_hash, ++ size, ++ ... ++ }), ++]; ++ ++meta = VideoMetadata { ++ ... ++ // refers to second element: assets[1] which is being uploaded to the storage system ++ video: 1, ++ // refers to the first element assets[0] which is being referneced by a url string. ++ thumbnail_photo: 0, ++ ... ++}; ++``` +\ No newline at end of file +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/generate-md-doc.sh b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/generate-md-doc.sh +new file mode 100755 +index 0000000..46b521b +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/generate-md-doc.sh +@@ -0,0 +1,13 @@ ++#!/usr/bin/env bash ++ ++# Directory to write generated documentation to ++OUT_DIR_DOC="./doc" ++mkdir -p ${OUT_DIR_DOC} ++ ++# Gernerate Markdown docs ++protoc \ ++ --doc_out="${OUT_DIR_DOC}" --doc_opt=markdown,index.md \ ++ proto/*.proto ++ ++# Append some custom docs to generated protocol docs ++cat doc-appendix.md >> ${OUT_DIR_DOC}/index.md +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/KnownLicenses.json b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/KnownLicenses.json +new file mode 100644 +index 0000000..d850733 +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/KnownLicenses.json +@@ -0,0 +1,74 @@ ++[ ++ { ++ "code": 1000, ++ "name": "CUSTOM", ++ "longName": "Custom License", ++ "description": "A user defined License", ++ "url": "", ++ "attributionRequired": false ++ }, ++ { ++ "code": 1001, ++ "name": "PDM", ++ "longName": "Public Domain", ++ "description": "For items which are not protected by copyright. This is not a license, but rather a copyright status. Some government-produced works, items with expired copyrights, and those which are ineligible for copyright protection may be included in this category.", ++ "url": "https://creativecommons.org/share-your-work/public-domain/pdm", ++ "attributionRequired": false ++ }, ++ { ++ "code": 1002, ++ "name": "CC0", ++ "longName": "Public Domain Dedication", ++ "description": "The CC0 (Public Domain Dedication) License allows creators to waive all rights to their creations and release them into the Public Domain.", ++ "url": "https://creativecommons.org/share-your-work/public-domain/cc0", ++ "attributionRequired": true ++ }, ++ { ++ "code": 1003, ++ "name": "CC_BY", ++ "longName": "Creative Commons Attribution License", ++ "description": "Sharing and adapting this content is permitted, but attribution must be provided. Read the License Deed for more information.", ++ "url": "https://creativecommons.org/licenses/by/4.0", ++ "attributionRequired": true ++ }, ++ { ++ "code": 1004, ++ "name": "CC_BY_SA", ++ "longName": "Creative Commons Attribution-ShareAlike License", ++ "description": "Sharing and adapting this content is permitted, but attribution must be provided. Any derivative works must be distributed under the same license. Read the License Deed for more information.", ++ "url": "https://creativecommons.org/licenses/by-sa/4.0", ++ "attributionRequired": true ++ }, ++ { ++ "code": 1005, ++ "name": "CC_BY_ND", ++ "longName": "Creative Commons Attribution-NoDerivs License", ++ "description": "Sharing this content is permitted, but attribution must be provided. You may not remix, transform, or build upon the material. Read the License Deed for more information.", ++ "url": "https://creativecommons.org/licenses/by-nd/4.0", ++ "attributionRequired": true ++ }, ++ { ++ "code": 1006, ++ "name": "CC_BY_NC", ++ "longName": "Creative Commons Attribution-NonCommercial License", ++ "description": "Sharing and adapting this content is permitted, but attribution must be provided. Commercial use is not permitted. Read the License Deed for more information.", ++ "url": "https://creativecommons.org/licenses/by-nc/4.0", ++ "attributionRequired": true ++ }, ++ { ++ "code": 1007, ++ "name": "CC_BY_NC_SA", ++ "longName": "Creative Commons Attribution-NonCommercial-ShareAlike License", ++ "description": "Sharing and adapting this content is permitted, but attribution must be provided. Any derivative works must be distributed under the same license. Commercial use is not permitted. Read the License Deed for more information.", ++ "url": "https://creativecommons.org/licenses/by-nc-sa/4.0", ++ "attributionRequired": true ++ }, ++ { ++ "code": 1008, ++ "name": "CC_BY_NC_ND", ++ "longName": "Creative Commons Attribution-NonCommercial-NoDerivs License", ++ "description": "Sharing this content is permitted, but attribution must be provided. You may not remix, transform, or build upon the material. Commercial use is not permitted. Read the License Deed for more information.", ++ "url": "https://creativecommons.org/licenses/by-nc-nd/4.0", ++ "attributionRequired": true ++ } ++] +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/consts.d.ts b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/consts.d.ts +new file mode 100644 +index 0000000..3160905 +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/consts.d.ts +@@ -0,0 +1 @@ ++export declare const MAX_TAGS_PER_FORUM_THREAD = 5; +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/consts.js b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/consts.js +new file mode 100644 +index 0000000..efb36af +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/consts.js +@@ -0,0 +1,4 @@ ++"use strict"; ++Object.defineProperty(exports, "__esModule", { value: true }); ++exports.MAX_TAGS_PER_FORUM_THREAD = void 0; ++exports.MAX_TAGS_PER_FORUM_THREAD = 5; +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/index.d.ts b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/index.d.ts +new file mode 100644 +index 0000000..042e85c +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/index.d.ts +@@ -0,0 +1 @@ ++export * from '../compiled'; +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/index.js b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/index.js +new file mode 100644 +index 0000000..2a96bfc +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/index.js +@@ -0,0 +1,18 @@ ++"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 }); ++// protobuf message constructors ++__exportStar(require("../compiled"), exports); +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/json/index.d.ts b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/json/index.d.ts +new file mode 100644 +index 0000000..76f77af +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/json/index.d.ts +@@ -0,0 +1,2 @@ ++import { nested } from './messages.json'; ++export default nested; +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/json/index.js b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/json/index.js +new file mode 100644 +index 0000000..f8ced4e +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/json/index.js +@@ -0,0 +1,4 @@ ++"use strict"; ++Object.defineProperty(exports, "__esModule", { value: true }); ++const messages_json_1 = require("./messages.json"); ++exports.default = messages_json_1.nested; +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/json/messages.json b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/json/messages.json +new file mode 100644 +index 0000000..f0f7bcd +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/json/messages.json +@@ -0,0 +1,1353 @@ ++{ ++ "nested": { ++ "AppActionMetadata": { ++ "fields": { ++ "videoId": { ++ "type": "string", ++ "id": 2 ++ } ++ } ++ }, ++ "AppAction": { ++ "fields": { ++ "appId": { ++ "rule": "required", ++ "type": "string", ++ "id": 999 ++ }, ++ "metadata": { ++ "type": "bytes", ++ "id": 2 ++ }, ++ "rawAction": { ++ "type": "bytes", ++ "id": 3 ++ }, ++ "signature": { ++ "type": "bytes", ++ "id": 4 ++ } ++ }, ++ "nested": { ++ "ActionType": { ++ "values": { ++ "CREATE_VIDEO": 0, ++ "CREATE_CHANNEL": 1 ++ } ++ }, ++ "CreatorType": { ++ "values": { ++ "CHANNEL": 0, ++ "MEMBER": 1, ++ "CURATOR_GROUP": 2 ++ } ++ } ++ } ++ }, ++ "BountyMetadata": { ++ "fields": { ++ "title": { ++ "type": "string", ++ "id": 1 ++ }, ++ "description": { ++ "type": "string", ++ "id": 2 ++ }, ++ "discussionThread": { ++ "type": "uint64", ++ "id": 3 ++ }, ++ "bannerImageUri": { ++ "type": "string", ++ "id": 4 ++ } ++ } ++ }, ++ "BountyWorkData": { ++ "fields": { ++ "title": { ++ "type": "string", ++ "id": 1 ++ }, ++ "description": { ++ "type": "string", ++ "id": 2 ++ } ++ } ++ }, ++ "ChannelMetadata": { ++ "fields": { ++ "title": { ++ "type": "string", ++ "id": 1 ++ }, ++ "description": { ++ "type": "string", ++ "id": 2 ++ }, ++ "isPublic": { ++ "type": "bool", ++ "id": 3 ++ }, ++ "language": { ++ "type": "string", ++ "id": 4 ++ }, ++ "coverPhoto": { ++ "type": "uint32", ++ "id": 5 ++ }, ++ "avatarPhoto": { ++ "type": "uint32", ++ "id": 6 ++ } ++ } ++ }, ++ "ChannelPayoutsMetadata": { ++ "fields": { ++ "header": { ++ "rule": "required", ++ "type": "Header", ++ "id": 1 ++ }, ++ "body": { ++ "rule": "required", ++ "type": "Body", ++ "id": 2 ++ } ++ }, ++ "nested": { ++ "Header": { ++ "fields": { ++ "payloadLengthInBytes": { ++ "rule": "required", ++ "type": "fixed64", ++ "id": 1 ++ }, ++ "headerLengthInBytes": { ++ "rule": "required", ++ "type": "fixed64", ++ "id": 2 ++ }, ++ "numberOfChannels": { ++ "rule": "required", ++ "type": "fixed32", ++ "id": 3 ++ }, ++ "channelPayoutByteOffsets": { ++ "rule": "repeated", ++ "type": "ChannelPayoutByteOffset", ++ "id": 4 ++ } ++ }, ++ "nested": { ++ "ChannelPayoutByteOffset": { ++ "fields": { ++ "channelId": { ++ "rule": "required", ++ "type": "fixed32", ++ "id": 1 ++ }, ++ "byteOffset": { ++ "rule": "required", ++ "type": "fixed64", ++ "id": 2 ++ } ++ } ++ } ++ } ++ }, ++ "Body": { ++ "fields": { ++ "channelPayouts": { ++ "rule": "repeated", ++ "type": "ChannelPayoutProof", ++ "id": 1 ++ } ++ }, ++ "nested": { ++ "ChannelPayoutProof": { ++ "fields": { ++ "channelId": { ++ "rule": "required", ++ "type": "uint32", ++ "id": 1 ++ }, ++ "cumulativeRewardEarned": { ++ "rule": "required", ++ "type": "string", ++ "id": 2 ++ }, ++ "merkleBranch": { ++ "rule": "repeated", ++ "type": "ProofElement", ++ "id": 3 ++ }, ++ "reason": { ++ "rule": "required", ++ "type": "string", ++ "id": 4 ++ } ++ }, ++ "nested": { ++ "Side": { ++ "values": { ++ "Left": 0, ++ "Right": 1 ++ } ++ }, ++ "ProofElement": { ++ "fields": { ++ "hash": { ++ "rule": "required", ++ "type": "string", ++ "id": 1 ++ }, ++ "side": { ++ "rule": "required", ++ "type": "Side", ++ "id": 2 ++ } ++ } ++ } ++ } ++ } ++ } ++ } ++ } ++ }, ++ "CouncilCandidacyNoteMetadata": { ++ "fields": { ++ "header": { ++ "type": "string", ++ "id": 1 ++ }, ++ "bulletPoints": { ++ "rule": "repeated", ++ "type": "string", ++ "id": 2 ++ }, ++ "bannerImageUri": { ++ "type": "string", ++ "id": 3 ++ }, ++ "description": { ++ "type": "string", ++ "id": 4 ++ } ++ } ++ }, ++ "ForumPostMetadata": { ++ "fields": { ++ "text": { ++ "type": "string", ++ "id": 1 ++ }, ++ "repliesTo": { ++ "type": "uint32", ++ "id": 2 ++ } ++ } ++ }, ++ "ForumThreadMetadata": { ++ "fields": { ++ "title": { ++ "type": "string", ++ "id": 1 ++ }, ++ "tags": { ++ "rule": "repeated", ++ "type": "string", ++ "id": 2 ++ } ++ } ++ }, ++ "MembershipMetadata": { ++ "oneofs": { ++ "avatar": { ++ "oneof": [ ++ "avatarObject", ++ "avatarUri" ++ ] ++ } ++ }, ++ "fields": { ++ "name": { ++ "type": "string", ++ "id": 1 ++ }, ++ "avatarObject": { ++ "type": "uint32", ++ "id": 2 ++ }, ++ "avatarUri": { ++ "type": "string", ++ "id": 4 ++ }, ++ "about": { ++ "type": "string", ++ "id": 3 ++ }, ++ "externalResources": { ++ "rule": "repeated", ++ "type": "ExternalResource", ++ "id": 5 ++ } ++ }, ++ "nested": { ++ "ExternalResource": { ++ "fields": { ++ "type": { ++ "type": "ResourceType", ++ "id": 1 ++ }, ++ "value": { ++ "type": "string", ++ "id": 2 ++ } ++ }, ++ "nested": { ++ "ResourceType": { ++ "values": { ++ "EMAIL": 0, ++ "HYPERLINK": 1, ++ "TWITTER": 2, ++ "TELEGRAM": 3, ++ "DISCORD": 4, ++ "FACEBOOK": 5, ++ "YOUTUBE": 6, ++ "MATRIX": 7, ++ "IRC": 8, ++ "WECHAT": 9, ++ "WHATSAPP": 10 ++ } ++ } ++ } ++ } ++ } ++ }, ++ "ReactVideo": { ++ "fields": { ++ "videoId": { ++ "rule": "required", ++ "type": "uint64", ++ "id": 1 ++ }, ++ "reaction": { ++ "rule": "required", ++ "type": "Reaction", ++ "id": 2 ++ } ++ }, ++ "nested": { ++ "Reaction": { ++ "values": { ++ "LIKE": 0, ++ "UNLIKE": 1 ++ } ++ } ++ } ++ }, ++ "ReactComment": { ++ "fields": { ++ "commentId": { ++ "rule": "required", ++ "type": "string", ++ "id": 1 ++ }, ++ "reactionId": { ++ "rule": "required", ++ "type": "uint32", ++ "id": 2 ++ } ++ } ++ }, ++ "CreateComment": { ++ "fields": { ++ "videoId": { ++ "rule": "required", ++ "type": "uint64", ++ "id": 1 ++ }, ++ "parentCommentId": { ++ "type": "string", ++ "id": 2 ++ }, ++ "body": { ++ "rule": "required", ++ "type": "string", ++ "id": 3 ++ } ++ } ++ }, ++ "EditComment": { ++ "fields": { ++ "commentId": { ++ "rule": "required", ++ "type": "string", ++ "id": 1 ++ }, ++ "newBody": { ++ "rule": "required", ++ "type": "string", ++ "id": 2 ++ } ++ } ++ }, ++ "DeleteComment": { ++ "fields": { ++ "commentId": { ++ "rule": "required", ++ "type": "string", ++ "id": 1 ++ } ++ } ++ }, ++ "PinOrUnpinComment": { ++ "fields": { ++ "videoId": { ++ "rule": "required", ++ "type": "uint64", ++ "id": 1 ++ }, ++ "commentId": { ++ "rule": "required", ++ "type": "string", ++ "id": 2 ++ }, ++ "option": { ++ "rule": "required", ++ "type": "Option", ++ "id": 3 ++ } ++ }, ++ "nested": { ++ "Option": { ++ "values": { ++ "PIN": 0, ++ "UNPIN": 1 ++ } ++ } ++ } ++ }, ++ "ModerateComment": { ++ "fields": { ++ "commentId": { ++ "rule": "required", ++ "type": "string", ++ "id": 1 ++ }, ++ "rationale": { ++ "rule": "required", ++ "type": "string", ++ "id": 2 ++ } ++ } ++ }, ++ "BanOrUnbanMemberFromChannel": { ++ "fields": { ++ "memberId": { ++ "rule": "required", ++ "type": "uint64", ++ "id": 1 ++ }, ++ "option": { ++ "rule": "required", ++ "type": "Option", ++ "id": 2 ++ } ++ }, ++ "nested": { ++ "Option": { ++ "values": { ++ "BAN": 0, ++ "UNBAN": 1 ++ } ++ } ++ } ++ }, ++ "VideoReactionsPreference": { ++ "fields": { ++ "videoId": { ++ "rule": "required", ++ "type": "uint64", ++ "id": 1 ++ }, ++ "option": { ++ "rule": "required", ++ "type": "Option", ++ "id": 2 ++ } ++ }, ++ "nested": { ++ "Option": { ++ "values": { ++ "ENABLE": 0, ++ "DISABLE": 1 ++ } ++ } ++ } ++ }, ++ "CreateVideoCategory": { ++ "fields": { ++ "name": { ++ "rule": "required", ++ "type": "string", ++ "id": 1 ++ }, ++ "description": { ++ "type": "string", ++ "id": 2 ++ }, ++ "parentCategoryId": { ++ "type": "string", ++ "id": 3 ++ } ++ } ++ }, ++ "MakeChannelPayment": { ++ "oneofs": { ++ "paymentContext": { ++ "oneof": [ ++ "videoId" ++ ] ++ } ++ }, ++ "fields": { ++ "rationale": { ++ "type": "string", ++ "id": 1 ++ }, ++ "videoId": { ++ "type": "uint64", ++ "id": 2 ++ } ++ } ++ }, ++ "AppMetadata": { ++ "fields": { ++ "websiteUrl": { ++ "type": "string", ++ "id": 2 ++ }, ++ "useUri": { ++ "type": "string", ++ "id": 3 ++ }, ++ "smallIcon": { ++ "type": "string", ++ "id": 4 ++ }, ++ "mediumIcon": { ++ "type": "string", ++ "id": 5 ++ }, ++ "bigIcon": { ++ "type": "string", ++ "id": 6 ++ }, ++ "oneLiner": { ++ "type": "string", ++ "id": 7 ++ }, ++ "description": { ++ "type": "string", ++ "id": 8 ++ }, ++ "termsOfService": { ++ "type": "string", ++ "id": 9 ++ }, ++ "authKey": { ++ "type": "string", ++ "id": 10 ++ }, ++ "platforms": { ++ "rule": "repeated", ++ "type": "string", ++ "id": 11 ++ }, ++ "category": { ++ "type": "string", ++ "id": 12 ++ } ++ } ++ }, ++ "CreateApp": { ++ "fields": { ++ "name": { ++ "rule": "required", ++ "type": "string", ++ "id": 1 ++ }, ++ "appMetadata": { ++ "type": "AppMetadata", ++ "id": 2 ++ } ++ } ++ }, ++ "UpdateApp": { ++ "fields": { ++ "appId": { ++ "rule": "required", ++ "type": "string", ++ "id": 1 ++ }, ++ "appMetadata": { ++ "type": "AppMetadata", ++ "id": 2 ++ } ++ } ++ }, ++ "MemberRemarked": { ++ "oneofs": { ++ "memberRemarked": { ++ "oneof": [ ++ "reactVideo", ++ "reactComment", ++ "createComment", ++ "editComment", ++ "deleteComment", ++ "createVideoCategory", ++ "createApp", ++ "updateApp", ++ "makeChannelPayment" ++ ] ++ } ++ }, ++ "fields": { ++ "reactVideo": { ++ "type": "ReactVideo", ++ "id": 1 ++ }, ++ "reactComment": { ++ "type": "ReactComment", ++ "id": 2 ++ }, ++ "createComment": { ++ "type": "CreateComment", ++ "id": 3 ++ }, ++ "editComment": { ++ "type": "EditComment", ++ "id": 4 ++ }, ++ "deleteComment": { ++ "type": "DeleteComment", ++ "id": 5 ++ }, ++ "createVideoCategory": { ++ "type": "CreateVideoCategory", ++ "id": 6 ++ }, ++ "createApp": { ++ "type": "CreateApp", ++ "id": 7 ++ }, ++ "updateApp": { ++ "type": "UpdateApp", ++ "id": 8 ++ }, ++ "makeChannelPayment": { ++ "type": "MakeChannelPayment", ++ "id": 10 ++ } ++ } ++ }, ++ "ChannelModeratorRemarked": { ++ "oneofs": { ++ "channelModeratorRemarked": { ++ "oneof": [ ++ "moderateComment" ++ ] ++ } ++ }, ++ "fields": { ++ "moderateComment": { ++ "type": "ModerateComment", ++ "id": 1 ++ } ++ } ++ }, ++ "ChannelOwnerRemarked": { ++ "oneofs": { ++ "channelOwnerRemarked": { ++ "oneof": [ ++ "pinOrUnpinComment", ++ "banOrUnbanMemberFromChannel", ++ "videoReactionsPreference", ++ "moderateComment" ++ ] ++ } ++ }, ++ "fields": { ++ "pinOrUnpinComment": { ++ "type": "PinOrUnpinComment", ++ "id": 1 ++ }, ++ "banOrUnbanMemberFromChannel": { ++ "type": "BanOrUnbanMemberFromChannel", ++ "id": 2 ++ }, ++ "videoReactionsPreference": { ++ "type": "VideoReactionsPreference", ++ "id": 3 ++ }, ++ "moderateComment": { ++ "type": "ModerateComment", ++ "id": 5 ++ } ++ } ++ }, ++ "PersonMetadata": { ++ "fields": { ++ "firstName": { ++ "type": "string", ++ "id": 1 ++ }, ++ "middleName": { ++ "type": "string", ++ "id": 2 ++ }, ++ "lastName": { ++ "type": "string", ++ "id": 3 ++ }, ++ "about": { ++ "type": "string", ++ "id": 4 ++ }, ++ "coverPhoto": { ++ "type": "uint32", ++ "id": 5 ++ }, ++ "avatarPhoto": { ++ "type": "uint32", ++ "id": 6 ++ } ++ } ++ }, ++ "ProposalsDiscussionPostMetadata": { ++ "fields": { ++ "text": { ++ "type": "string", ++ "id": 1 ++ }, ++ "repliesTo": { ++ "type": "uint32", ++ "id": 2 ++ } ++ } ++ }, ++ "SeriesMetadata": { ++ "fields": { ++ "title": { ++ "type": "string", ++ "id": 1 ++ }, ++ "description": { ++ "type": "string", ++ "id": 2 ++ }, ++ "coverPhoto": { ++ "type": "uint32", ++ "id": 3 ++ }, ++ "persons": { ++ "rule": "repeated", ++ "type": "uint64", ++ "id": 4 ++ } ++ } ++ }, ++ "SeasonMetadata": { ++ "fields": { ++ "title": { ++ "type": "string", ++ "id": 1 ++ }, ++ "description": { ++ "type": "string", ++ "id": 2 ++ }, ++ "coverPhoto": { ++ "type": "uint32", ++ "id": 3 ++ }, ++ "persons": { ++ "rule": "repeated", ++ "type": "uint64", ++ "id": 4 ++ } ++ } ++ }, ++ "GeoCoordiantes": { ++ "fields": { ++ "latitude": { ++ "type": "float", ++ "id": 3 ++ }, ++ "longitude": { ++ "type": "float", ++ "id": 4 ++ } ++ } ++ }, ++ "NodeLocationMetadata": { ++ "fields": { ++ "countryCode": { ++ "type": "string", ++ "id": 1 ++ }, ++ "city": { ++ "type": "string", ++ "id": 2 ++ }, ++ "coordinates": { ++ "type": "GeoCoordiantes", ++ "id": 3 ++ } ++ } ++ }, ++ "StorageBucketOperatorMetadata": { ++ "fields": { ++ "endpoint": { ++ "type": "string", ++ "id": 1 ++ }, ++ "location": { ++ "type": "NodeLocationMetadata", ++ "id": 2 ++ }, ++ "extra": { ++ "type": "string", ++ "id": 3 ++ } ++ } ++ }, ++ "DistributionBucketOperatorMetadata": { ++ "fields": { ++ "endpoint": { ++ "type": "string", ++ "id": 1 ++ }, ++ "location": { ++ "type": "NodeLocationMetadata", ++ "id": 2 ++ }, ++ "extra": { ++ "type": "string", ++ "id": 3 ++ } ++ } ++ }, ++ "GeographicalArea": { ++ "oneofs": { ++ "code": { ++ "oneof": [ ++ "continent", ++ "countryCode", ++ "subdivisionCode" ++ ] ++ } ++ }, ++ "fields": { ++ "continent": { ++ "type": "Continent", ++ "id": 1 ++ }, ++ "countryCode": { ++ "type": "string", ++ "id": 2 ++ }, ++ "subdivisionCode": { ++ "type": "string", ++ "id": 3 ++ } ++ }, ++ "nested": { ++ "Continent": { ++ "values": { ++ "AF": 1, ++ "NA": 2, ++ "OC": 3, ++ "AN": 4, ++ "AS": 5, ++ "EU": 6, ++ "SA": 7 ++ } ++ } ++ } ++ }, ++ "DistributionBucketFamilyMetadata": { ++ "fields": { ++ "region": { ++ "type": "string", ++ "id": 1 ++ }, ++ "description": { ++ "type": "string", ++ "id": 2 ++ }, ++ "areas": { ++ "rule": "repeated", ++ "type": "GeographicalArea", ++ "id": 3 ++ }, ++ "latencyTestTargets": { ++ "rule": "repeated", ++ "type": "string", ++ "id": 4 ++ } ++ } ++ }, ++ "CreatorTokenIssuerRemarked": { ++ "oneofs": { ++ "creatorTokenIssuerRemarked": { ++ "oneof": [ ++ "updateTokenMetadata" ++ ] ++ } ++ }, ++ "fields": { ++ "updateTokenMetadata": { ++ "type": "UpdateTokenMetadata", ++ "id": 1 ++ } ++ } ++ }, ++ "UpdateTokenMetadata": { ++ "fields": { ++ "newMetadata": { ++ "type": "TokenMetadata", ++ "id": 1 ++ } ++ } ++ }, ++ "TokenMetadata": { ++ "oneofs": { ++ "avatar": { ++ "oneof": [ ++ "avatarObject", ++ "avatarUri" ++ ] ++ } ++ }, ++ "fields": { ++ "name": { ++ "type": "string", ++ "id": 1 ++ }, ++ "symbol": { ++ "rule": "required", ++ "type": "string", ++ "id": 2 ++ }, ++ "description": { ++ "type": "string", ++ "id": 3 ++ }, ++ "avatarObject": { ++ "type": "uint32", ++ "id": 4 ++ }, ++ "avatarUri": { ++ "type": "string", ++ "id": 5 ++ }, ++ "benefits": { ++ "rule": "repeated", ++ "type": "Benefit", ++ "id": 6 ++ }, ++ "whitelistApplicationNote": { ++ "type": "string", ++ "id": 7 ++ }, ++ "whitelistApplicationApplyLink": { ++ "type": "string", ++ "id": 8 ++ }, ++ "trailerVideoId": { ++ "type": "uint64", ++ "id": 9 ++ } ++ } ++ }, ++ "Benefit": { ++ "fields": { ++ "title": { ++ "type": "string", ++ "id": 1 ++ }, ++ "description": { ++ "type": "string", ++ "id": 2 ++ }, ++ "emoji": { ++ "type": "string", ++ "id": 3 ++ }, ++ "displayOrder": { ++ "type": "uint32", ++ "id": 4 ++ } ++ } ++ }, ++ "SaleMetadata": { ++ "fields": { ++ "termsAndConditions": { ++ "type": "string", ++ "id": 1 ++ } ++ } ++ }, ++ "PublishedBeforeJoystream": { ++ "fields": { ++ "isPublished": { ++ "type": "bool", ++ "id": 1 ++ }, ++ "date": { ++ "type": "string", ++ "id": 2 ++ } ++ } ++ }, ++ "License": { ++ "fields": { ++ "code": { ++ "type": "uint32", ++ "id": 1 ++ }, ++ "attribution": { ++ "type": "string", ++ "id": 2 ++ }, ++ "customText": { ++ "type": "string", ++ "id": 3 ++ } ++ } ++ }, ++ "MediaType": { ++ "fields": { ++ "codecName": { ++ "type": "string", ++ "id": 1 ++ }, ++ "container": { ++ "type": "string", ++ "id": 2 ++ }, ++ "mimeMediaType": { ++ "type": "string", ++ "id": 3 ++ } ++ } ++ }, ++ "SubtitleMetadata": { ++ "fields": { ++ "type": { ++ "rule": "required", ++ "type": "string", ++ "id": 1 ++ }, ++ "newAsset": { ++ "type": "uint32", ++ "id": 2 ++ }, ++ "language": { ++ "rule": "required", ++ "type": "string", ++ "id": 3 ++ }, ++ "mimeType": { ++ "rule": "required", ++ "type": "string", ++ "id": 4 ++ } ++ } ++ }, ++ "VideoMetadata": { ++ "fields": { ++ "title": { ++ "type": "string", ++ "id": 1 ++ }, ++ "description": { ++ "type": "string", ++ "id": 2 ++ }, ++ "video": { ++ "type": "uint32", ++ "id": 3 ++ }, ++ "thumbnailPhoto": { ++ "type": "uint32", ++ "id": 4 ++ }, ++ "duration": { ++ "type": "uint32", ++ "id": 5 ++ }, ++ "mediaPixelHeight": { ++ "type": "uint32", ++ "id": 6 ++ }, ++ "mediaPixelWidth": { ++ "type": "uint32", ++ "id": 7 ++ }, ++ "mediaType": { ++ "type": "MediaType", ++ "id": 8 ++ }, ++ "language": { ++ "type": "string", ++ "id": 9 ++ }, ++ "license": { ++ "type": "License", ++ "id": 10 ++ }, ++ "publishedBeforeJoystream": { ++ "type": "PublishedBeforeJoystream", ++ "id": 11 ++ }, ++ "hasMarketing": { ++ "type": "bool", ++ "id": 12 ++ }, ++ "isPublic": { ++ "type": "bool", ++ "id": 13 ++ }, ++ "isExplicit": { ++ "type": "bool", ++ "id": 14 ++ }, ++ "persons": { ++ "rule": "repeated", ++ "type": "uint64", ++ "id": 15 ++ }, ++ "category": { ++ "type": "string", ++ "id": 16 ++ }, ++ "subtitles": { ++ "rule": "repeated", ++ "type": "SubtitleMetadata", ++ "id": 17 ++ }, ++ "enableComments": { ++ "type": "bool", ++ "id": 18 ++ }, ++ "clearSubtitles": { ++ "type": "bool", ++ "id": 19 ++ } ++ } ++ }, ++ "ContentMetadata": { ++ "oneofs": { ++ "contentMetadata": { ++ "oneof": [ ++ "videoMetadata" ++ ] ++ } ++ }, ++ "fields": { ++ "videoMetadata": { ++ "type": "VideoMetadata", ++ "id": 1 ++ } ++ } ++ }, ++ "OpeningMetadata": { ++ "fields": { ++ "shortDescription": { ++ "type": "string", ++ "id": 1 ++ }, ++ "description": { ++ "type": "string", ++ "id": 2 ++ }, ++ "hiringLimit": { ++ "type": "uint32", ++ "id": 3 ++ }, ++ "expectedEndingTimestamp": { ++ "type": "uint32", ++ "id": 4 ++ }, ++ "applicationDetails": { ++ "type": "string", ++ "id": 5 ++ }, ++ "applicationFormQuestions": { ++ "rule": "repeated", ++ "type": "ApplicationFormQuestion", ++ "id": 6 ++ }, ++ "title": { ++ "type": "string", ++ "id": 7 ++ } ++ }, ++ "nested": { ++ "ApplicationFormQuestion": { ++ "fields": { ++ "question": { ++ "type": "string", ++ "id": 1 ++ }, ++ "type": { ++ "type": "InputType", ++ "id": 2 ++ } ++ }, ++ "nested": { ++ "InputType": { ++ "values": { ++ "TEXTAREA": 0, ++ "TEXT": 1 ++ } ++ } ++ } ++ } ++ } ++ }, ++ "UpcomingOpeningMetadata": { ++ "fields": { ++ "expectedStart": { ++ "type": "uint32", ++ "id": 1 ++ }, ++ "rewardPerBlock": { ++ "type": "uint64", ++ "id": 2 ++ }, ++ "minApplicationStake": { ++ "type": "uint64", ++ "id": 3 ++ }, ++ "metadata": { ++ "type": "OpeningMetadata", ++ "id": 4 ++ } ++ } ++ }, ++ "ApplicationMetadata": { ++ "fields": { ++ "answers": { ++ "rule": "repeated", ++ "type": "string", ++ "id": 1 ++ } ++ } ++ }, ++ "WorkingGroupMetadata": { ++ "fields": { ++ "description": { ++ "type": "string", ++ "id": 1 ++ }, ++ "about": { ++ "type": "string", ++ "id": 2 ++ }, ++ "status": { ++ "type": "string", ++ "id": 3 ++ }, ++ "statusMessage": { ++ "type": "string", ++ "id": 4 ++ } ++ } ++ }, ++ "SetGroupMetadata": { ++ "fields": { ++ "newMetadata": { ++ "type": "WorkingGroupMetadata", ++ "id": 1 ++ } ++ } ++ }, ++ "AddUpcomingOpening": { ++ "fields": { ++ "metadata": { ++ "type": "UpcomingOpeningMetadata", ++ "id": 1 ++ } ++ } ++ }, ++ "RemoveUpcomingOpening": { ++ "fields": { ++ "id": { ++ "type": "string", ++ "id": 1 ++ } ++ } ++ }, ++ "WorkingGroupMetadataAction": { ++ "oneofs": { ++ "action": { ++ "oneof": [ ++ "setGroupMetadata", ++ "addUpcomingOpening", ++ "removeUpcomingOpening" ++ ] ++ } ++ }, ++ "fields": { ++ "setGroupMetadata": { ++ "type": "SetGroupMetadata", ++ "id": 1 ++ }, ++ "addUpcomingOpening": { ++ "type": "AddUpcomingOpening", ++ "id": 2 ++ }, ++ "removeUpcomingOpening": { ++ "type": "RemoveUpcomingOpening", ++ "id": 3 ++ } ++ } ++ }, ++ "ModeratePost": { ++ "fields": { ++ "postId": { ++ "rule": "required", ++ "type": "uint64", ++ "id": 1 ++ }, ++ "rationale": { ++ "rule": "required", ++ "type": "string", ++ "id": 2 ++ } ++ } ++ }, ++ "RemarkMetadataAction": { ++ "oneofs": { ++ "action": { ++ "oneof": [ ++ "moderatePost" ++ ] ++ } ++ }, ++ "fields": { ++ "moderatePost": { ++ "type": "ModeratePost", ++ "id": 1 ++ } ++ } ++ } ++ } ++} +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/licenses.d.ts b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/licenses.d.ts +new file mode 100644 +index 0000000..a6b2b2f +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/licenses.d.ts +@@ -0,0 +1,23 @@ ++import { License } from '../compiled/index'; ++export declare type LicenseCode = number; ++export declare const CUSTOM_LICENSE_CODE: LicenseCode; ++declare type KnownLicense = { ++ code: LicenseCode; ++ name: string; ++ longName: string; ++ description: string; ++ url: string; ++ attributionRequired: boolean; ++}; ++export declare const KnownLicenses: Map; ++export declare function getLicenseCodeByName(name: string): LicenseCode | undefined; ++export declare function createKnownLicenseFromCode(code: LicenseCode, attribution?: string): License; ++export declare function createCustomKnownLicense(customText: string): License; ++declare const _default: { ++ CUSTOM_LICENSE_CODE: number; ++ KnownLicenses: Map; ++ createCustomKnownLicense: typeof createCustomKnownLicense; ++ createKnownLicenseFromCode: typeof createKnownLicenseFromCode; ++ getLicenseCodeByName: typeof getLicenseCodeByName; ++}; ++export default _default; +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/licenses.js b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/licenses.js +new file mode 100644 +index 0000000..9766da1 +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/licenses.js +@@ -0,0 +1,51 @@ ++"use strict"; ++// Helper methods to handle joystream defined license types ++// This should be factored out into a separate package ++var __importDefault = (this && this.__importDefault) || function (mod) { ++ return (mod && mod.__esModule) ? mod : { "default": mod }; ++}; ++Object.defineProperty(exports, "__esModule", { value: true }); ++exports.createCustomKnownLicense = exports.createKnownLicenseFromCode = exports.getLicenseCodeByName = exports.KnownLicenses = exports.CUSTOM_LICENSE_CODE = void 0; ++const KnownLicenses_json_1 = __importDefault(require("./KnownLicenses.json")); ++const index_1 = require("../compiled/index"); ++exports.CUSTOM_LICENSE_CODE = 1000; ++exports.KnownLicenses = new Map(); ++KnownLicenses_json_1.default.forEach((license) => { ++ exports.KnownLicenses.set(license.code, license); ++}); ++function getLicenseCodeByName(name) { ++ for (const [code, license] of exports.KnownLicenses) { ++ if (license.name === name) ++ return code; ++ } ++} ++exports.getLicenseCodeByName = getLicenseCodeByName; ++function createKnownLicenseFromCode(code, attribution) { ++ if (code === exports.CUSTOM_LICENSE_CODE) { ++ throw new Error('Use createCustomLicense() instead'); ++ } ++ const knownLicense = exports.KnownLicenses.get(code); ++ if (!knownLicense) { ++ throw new Error('Unknown License Code'); ++ } ++ const license = new index_1.License({ code }); ++ if (knownLicense.attributionRequired) { ++ if (attribution === undefined) { ++ throw new Error('Attribution required for selected license'); ++ } ++ license.attribution = attribution; ++ } ++ return license; ++} ++exports.createKnownLicenseFromCode = createKnownLicenseFromCode; ++function createCustomKnownLicense(customText) { ++ return new index_1.License({ code: exports.CUSTOM_LICENSE_CODE, customText }); ++} ++exports.createCustomKnownLicense = createCustomKnownLicense; ++exports.default = { ++ CUSTOM_LICENSE_CODE: exports.CUSTOM_LICENSE_CODE, ++ KnownLicenses: exports.KnownLicenses, ++ createCustomKnownLicense, ++ createKnownLicenseFromCode, ++ getLicenseCodeByName, ++}; +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/types.d.ts b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/types.d.ts +new file mode 100644 +index 0000000..dd7db96 +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/types.d.ts +@@ -0,0 +1,23 @@ ++import { Long } from 'long'; ++import { IConversionOptions } from 'protobufjs'; ++export declare type AnyMessage = T & { ++ toJSON(): Record; ++}; ++export declare type AnyMetadataClass = { ++ new (): T; ++ name: string; ++ decode(binary: Uint8Array): AnyMessage; ++ encode(obj: T): { ++ finish(): Uint8Array; ++ }; ++ toObject(obj: AnyMessage, options?: IConversionOptions): Record; ++ verify(message: { ++ [k: string]: unknown; ++ }): null | string; ++ fromObject(object: { ++ [k: string]: unknown; ++ }): AnyMessage; ++}; ++export declare type DecodedMetadataObject = { ++ [K in keyof T]: T[K] extends Long | null | undefined ? Exclude | string : T[K] extends string | number | boolean | Uint8Array | null | undefined ? T[K] : T[K] extends Array ? DecodedMetadataObject[] : DecodedMetadataObject; ++}; +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/types.js b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/types.js +new file mode 100644 +index 0000000..c8ad2e5 +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/types.js +@@ -0,0 +1,2 @@ ++"use strict"; ++Object.defineProperty(exports, "__esModule", { value: true }); +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/utils.d.ts b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/utils.d.ts +new file mode 100644 +index 0000000..4ad0245 +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/utils.d.ts +@@ -0,0 +1,11 @@ ++import { AnyMessage, AnyMetadataClass, DecodedMetadataObject } from './types'; ++export declare function isSet(v: T | null | undefined): v is T; ++export declare function isEmptyObject(object: T): boolean; ++export declare function integrateMeta(object: T, meta: M, props: Props): void; ++export declare function encodeDecode(metaClass: AnyMetadataClass, value: T): DecodedMetadataObject; ++export declare function metaToObject(metaClass: AnyMetadataClass, value: AnyMessage): DecodedMetadataObject; ++export declare function isValidCountryCode(code: string): boolean; ++export declare function isValidLanguageCode(code: string): boolean; ++export declare function isValidSubdivisionCode(code: string): boolean; +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/utils.js b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/utils.js +new file mode 100644 +index 0000000..665afd0 +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/lib/utils.js +@@ -0,0 +1,51 @@ ++"use strict"; ++var __importDefault = (this && this.__importDefault) || function (mod) { ++ return (mod && mod.__esModule) ? mod : { "default": mod }; ++}; ++Object.defineProperty(exports, "__esModule", { value: true }); ++exports.isValidSubdivisionCode = exports.isValidLanguageCode = exports.isValidCountryCode = exports.metaToObject = exports.encodeDecode = exports.integrateMeta = exports.isEmptyObject = exports.isSet = void 0; ++const i18n_iso_countries_1 = __importDefault(require("i18n-iso-countries")); ++const iso_639_1_1 = __importDefault(require("iso-639-1")); ++const iso_3166_2_1 = __importDefault(require("iso-3166-2")); ++function isSet(v) { ++ return v !== null && v !== undefined; ++} ++exports.isSet = isSet; ++function isEmptyObject(object) { ++ return Object.keys(object).length === 0; ++} ++exports.isEmptyObject = isEmptyObject; ++function integrateMeta(object, meta, props) { ++ props.forEach((prop) => { ++ const metaPropVal = meta[prop]; ++ if (isSet(metaPropVal)) { ++ object[prop] = metaPropVal; ++ } ++ }); ++} ++exports.integrateMeta = integrateMeta; ++function encodeDecode(metaClass, value) { ++ const encoded = metaClass.encode(value).finish(); ++ return metaToObject(metaClass, metaClass.decode(encoded)); ++} ++exports.encodeDecode = encodeDecode; ++function metaToObject(metaClass, value) { ++ // Default conversion options - use Strings for "Long" values and ignore unset "repeated" fields ++ return metaClass.toObject(value, { arrays: false, longs: String }); ++} ++exports.metaToObject = metaToObject; ++// Checks if the provided code is valid according to ISO 3166-1 alpha-2 standard ++function isValidCountryCode(code) { ++ return i18n_iso_countries_1.default.getAlpha2Codes()[code] !== undefined; ++} ++exports.isValidCountryCode = isValidCountryCode; ++// Checks if the provided code is valid according to ISO 639-1 standard ++function isValidLanguageCode(code) { ++ return iso_639_1_1.default.validate(code); ++} ++exports.isValidLanguageCode = isValidLanguageCode; ++// According to ISO 3166-2 standard ++function isValidSubdivisionCode(code) { ++ return !!iso_3166_2_1.default.subdivision(code); ++} ++exports.isValidSubdivisionCode = isValidSubdivisionCode; +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/node_modules/.bin/_mocha b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/node_modules/.bin/_mocha +new file mode 100755 +index 0000000..2ea8317 +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/node_modules/.bin/_mocha +@@ -0,0 +1,10 @@ ++#!/usr/bin/env node ++'use strict'; ++ ++/** ++ * This file remains for backwards compatibility only. ++ * Don't put stuff in this file. ++ * @see module:lib/cli ++ */ ++ ++require('../lib/cli').main(); +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/node_modules/.bin/eslint b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/node_modules/.bin/eslint +new file mode 100755 +index 0000000..5fa5766 +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/node_modules/.bin/eslint +@@ -0,0 +1,136 @@ ++#!/usr/bin/env node ++ ++/** ++ * @fileoverview Main CLI that is run via the eslint command. ++ * @author Nicholas C. Zakas ++ */ ++ ++/* eslint no-console:off */ ++ ++"use strict"; ++ ++// to use V8's code cache to speed up instantiation time ++require("v8-compile-cache"); ++ ++// must do this initialization *before* other requires in order to work ++if (process.argv.includes("--debug")) { ++ require("debug").enable("eslint:*,-eslint:code-path,eslintrc:*"); ++} ++ ++//------------------------------------------------------------------------------ ++// Helpers ++//------------------------------------------------------------------------------ ++ ++/** ++ * Read data from stdin til the end. ++ * ++ * Note: See ++ * - https://github.com/nodejs/node/blob/master/doc/api/process.md#processstdin ++ * - https://github.com/nodejs/node/blob/master/doc/api/process.md#a-note-on-process-io ++ * - https://lists.gnu.org/archive/html/bug-gnu-emacs/2016-01/msg00419.html ++ * - https://github.com/nodejs/node/issues/7439 (historical) ++ * ++ * On Windows using `fs.readFileSync(STDIN_FILE_DESCRIPTOR, "utf8")` seems ++ * to read 4096 bytes before blocking and never drains to read further data. ++ * ++ * The investigation on the Emacs thread indicates: ++ * ++ * > Emacs on MS-Windows uses pipes to communicate with subprocesses; a ++ * > pipe on Windows has a 4K buffer. So as soon as Emacs writes more than ++ * > 4096 bytes to the pipe, the pipe becomes full, and Emacs then waits for ++ * > the subprocess to read its end of the pipe, at which time Emacs will ++ * > write the rest of the stuff. ++ * @returns {Promise} The read text. ++ */ ++function readStdin() { ++ return new Promise((resolve, reject) => { ++ let content = ""; ++ let chunk = ""; ++ ++ process.stdin ++ .setEncoding("utf8") ++ .on("readable", () => { ++ while ((chunk = process.stdin.read()) !== null) { ++ content += chunk; ++ } ++ }) ++ .on("end", () => resolve(content)) ++ .on("error", reject); ++ }); ++} ++ ++/** ++ * Get the error message of a given value. ++ * @param {any} error The value to get. ++ * @returns {string} The error message. ++ */ ++function getErrorMessage(error) { ++ ++ // Lazy loading because this is used only if an error happened. ++ const util = require("util"); ++ ++ // Foolproof -- thirdparty module might throw non-object. ++ if (typeof error !== "object" || error === null) { ++ return String(error); ++ } ++ ++ // Use templates if `error.messageTemplate` is present. ++ if (typeof error.messageTemplate === "string") { ++ try { ++ const template = require(`../messages/${error.messageTemplate}.js`); ++ ++ return template(error.messageData || {}); ++ } catch { ++ ++ // Ignore template error then fallback to use `error.stack`. ++ } ++ } ++ ++ // Use the stacktrace if it's an error object. ++ if (typeof error.stack === "string") { ++ return error.stack; ++ } ++ ++ // Otherwise, dump the object. ++ return util.format("%o", error); ++} ++ ++/** ++ * Catch and report unexpected error. ++ * @param {any} error The thrown error object. ++ * @returns {void} ++ */ ++function onFatalError(error) { ++ process.exitCode = 2; ++ ++ const { version } = require("../package.json"); ++ const message = getErrorMessage(error); ++ ++ console.error(` ++Oops! Something went wrong! :( ++ ++ESLint: ${version} ++ ++${message}`); ++} ++ ++//------------------------------------------------------------------------------ ++// Execution ++//------------------------------------------------------------------------------ ++ ++(async function main() { ++ process.on("uncaughtException", onFatalError); ++ process.on("unhandledRejection", onFatalError); ++ ++ // Call the config initializer if `--init` is present. ++ if (process.argv.includes("--init")) { ++ await require("../lib/init/config-initializer").initializeConfig(); ++ return; ++ } ++ ++ // Otherwise, call the CLI. ++ process.exitCode = await require("../lib/cli").execute( ++ process.argv, ++ process.argv.includes("--stdin") ? await readStdin() : null ++ ); ++}()).catch(onFatalError); +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/node_modules/.bin/mocha b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/node_modules/.bin/mocha +new file mode 100755 +index 0000000..79d3556 +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/node_modules/.bin/mocha +@@ -0,0 +1,151 @@ ++#!/usr/bin/env node ++ ++'use strict'; ++ ++/** ++ * This wrapper executable checks for known node flags and appends them when found, ++ * before invoking the "real" executable (`lib/cli/cli.js`) ++ * ++ * @module bin/mocha ++ * @private ++ */ ++ ++const {deprecate} = require('../lib/utils'); ++const {loadOptions} = require('../lib/cli/options'); ++const { ++ unparseNodeFlags, ++ isNodeFlag, ++ impliesNoTimeouts ++} = require('../lib/cli/node-flags'); ++const unparse = require('yargs-unparser'); ++const debug = require('debug')('mocha:cli:mocha'); ++const {aliases} = require('../lib/cli/run-option-metadata'); ++ ++const mochaArgs = {}; ++const nodeArgs = {}; ++ ++const opts = loadOptions(process.argv.slice(2)); ++debug('loaded opts', opts); ++ ++/** ++ * Given option/command `value`, disable timeouts if applicable ++ * @param {string} [value] - Value to check ++ * @ignore ++ */ ++const disableTimeouts = value => { ++ if (impliesNoTimeouts(value)) { ++ debug('option %s disabled timeouts', value); ++ mochaArgs.timeout = 0; ++ } ++}; ++ ++/** ++ * If `value` begins with `v8-` and is not explicitly `v8-options`, remove prefix ++ * @param {string} [value] - Value to check ++ * @returns {string} `value` with prefix (maybe) removed ++ * @ignore ++ */ ++const trimV8Option = value => ++ value !== 'v8-options' && /^v8-/.test(value) ? value.slice(3) : value; ++ ++// sort options into "node" and "mocha" buckets ++Object.keys(opts).forEach(opt => { ++ if (isNodeFlag(opt)) { ++ nodeArgs[trimV8Option(opt)] = opts[opt]; ++ } else { ++ mochaArgs[opt] = opts[opt]; ++ } ++}); ++ ++// disable 'timeout' for debugFlags ++Object.keys(nodeArgs).forEach(opt => disableTimeouts(opt)); ++ ++// Native debugger handling ++// see https://nodejs.org/api/debugger.html#debugger_debugger ++// look for 'inspect' or 'debug' that would launch this debugger, ++// remove it from Mocha's opts and prepend it to Node's opts. ++// A deprecation warning will be printed by node, if applicable. ++// (mochaArgs._ are "positional" arguments, not prefixed with - or --) ++if (mochaArgs._) { ++ const i = mochaArgs._.findIndex(val => val === 'inspect' || val === 'debug'); ++ if (i > -1) { ++ const [command] = mochaArgs._.splice(i, 1); ++ disableTimeouts('inspect'); ++ nodeArgs._ = [command]; ++ } ++} ++ ++// historical ++if (nodeArgs.gc) { ++ deprecate( ++ '"-gc" is deprecated and will be removed from a future version of Mocha. Use "--gc-global" instead.' ++ ); ++ nodeArgs['gc-global'] = nodeArgs.gc; ++ delete nodeArgs.gc; ++} ++ ++// --require/-r is treated as Mocha flag except when 'esm' is preloaded ++if (mochaArgs.require && mochaArgs.require.includes('esm')) { ++ nodeArgs.require = ['esm']; ++ mochaArgs.require = mochaArgs.require.filter(mod => mod !== 'esm'); ++ if (!mochaArgs.require.length) { ++ delete mochaArgs.require; ++ } ++} ++ ++if (Object.keys(nodeArgs).length) { ++ const {spawn} = require('child_process'); ++ const mochaPath = require.resolve('../lib/cli/cli.js'); ++ ++ debug('final node args', nodeArgs); ++ ++ const args = [].concat( ++ unparseNodeFlags(nodeArgs), ++ mochaPath, ++ unparse(mochaArgs, {alias: aliases}) ++ ); ++ ++ debug( ++ 'forking child process via command: %s %s', ++ process.execPath, ++ args.join(' ') ++ ); ++ ++ const proc = spawn(process.execPath, args, { ++ stdio: 'inherit' ++ }); ++ ++ proc.on('exit', (code, signal) => { ++ process.on('exit', () => { ++ if (signal) { ++ process.kill(process.pid, signal); ++ } else { ++ process.exit(code); ++ } ++ }); ++ }); ++ ++ // terminate children. ++ process.on('SIGINT', () => { ++ // XXX: a previous comment said this would abort the runner, but I can't see that it does ++ // anything with the default runner. ++ debug('main process caught SIGINT'); ++ proc.kill('SIGINT'); ++ // if running in parallel mode, we will have a proper SIGINT handler, so the below won't ++ // be needed. ++ if (!args.parallel || args.jobs < 2) { ++ // win32 does not support SIGTERM, so use next best thing. ++ if (require('os').platform() === 'win32') { ++ proc.kill('SIGKILL'); ++ } else { ++ // using SIGKILL won't cleanly close the output streams, which can result ++ // in cut-off text or a befouled terminal. ++ debug('sending SIGTERM to child process'); ++ proc.kill('SIGTERM'); ++ } ++ } ++ }); ++} else { ++ debug('running Mocha in-process'); ++ require('../lib/cli/cli').main(unparse(mochaArgs, {alias: aliases})); ++} +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/node_modules/.bin/pbjs b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/node_modules/.bin/pbjs +new file mode 100755 +index 0000000..6a5d49a +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/node_modules/.bin/pbjs +@@ -0,0 +1,6 @@ ++#!/usr/bin/env node ++var path = require("path"), ++ cli = require(path.join(__dirname, "..", "cli", "pbjs.js")); ++var ret = cli.main(process.argv.slice(2)); ++if (typeof ret === 'number') ++ process.exit(ret); +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/node_modules/.bin/pbts b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/node_modules/.bin/pbts +new file mode 100755 +index 0000000..cb1cdaf +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/node_modules/.bin/pbts +@@ -0,0 +1,6 @@ ++#!/usr/bin/env node ++var path = require("path"), ++ cli = require(path.join(__dirname, "..", "cli", "pbts.js")); ++var ret = cli.main(process.argv.slice(2)); ++if (typeof ret === 'number') ++ process.exit(ret); +diff --git a/node_modules/@joystream/metadata-protobuf/metadata-protobuf/node_modules/.bin/prettier b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/node_modules/.bin/prettier +new file mode 100755 +index 0000000..f26ebb0 +--- /dev/null ++++ b/node_modules/@joystream/metadata-protobuf/metadata-protobuf/node_modules/.bin/prettier +@@ -0,0 +1,53426 @@ ++#!/usr/bin/env node ++'use strict'; ++ ++function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } ++ ++var fs$2 = _interopDefault(require('fs')); ++var path$1 = _interopDefault(require('path')); ++var os = _interopDefault(require('os')); ++var tty = _interopDefault(require('tty')); ++var assert = _interopDefault(require('assert')); ++var util$3 = _interopDefault(require('util')); ++var stream$5 = _interopDefault(require('stream')); ++var events = _interopDefault(require('events')); ++var readline = _interopDefault(require('readline')); ++ ++var semverCompare = function cmp(a, b) { ++ var pa = a.split('.'); ++ var pb = b.split('.'); ++ ++ for (var i = 0; i < 3; i++) { ++ var na = Number(pa[i]); ++ var nb = Number(pb[i]); ++ if (na > nb) return 1; ++ if (nb > na) return -1; ++ if (!isNaN(na) && isNaN(nb)) return 1; ++ if (isNaN(na) && !isNaN(nb)) return -1; ++ } ++ ++ return 0; ++}; ++ ++var pleaseUpgradeNode = function pleaseUpgradeNode(pkg, opts) { ++ var opts = opts || {}; ++ var requiredVersion = pkg.engines.node.replace('>=', ''); ++ var currentVersion = process.version.replace('v', ''); ++ ++ if (semverCompare(currentVersion, requiredVersion) === -1) { ++ if (opts.message) { ++ console.error(opts.message(requiredVersion)); ++ } else { ++ console.error(pkg.name + ' requires at least version ' + requiredVersion + ' of Node, please upgrade'); ++ } ++ ++ if (opts.hasOwnProperty('exitCode')) { ++ process.exit(opts.exitCode); ++ } else { ++ process.exit(1); ++ } ++ } ++}; ++ ++var name = "prettier"; ++var version = "2.0.2"; ++var description = "Prettier is an opinionated code formatter"; ++var bin = "./bin/prettier.js"; ++var repository = "prettier/prettier"; ++var homepage = "https://prettier.io"; ++var author = "James Long"; ++var license = "MIT"; ++var main = "./index.js"; ++var engines = { ++ node: ">=10.13.0" ++}; ++var dependencies = { ++ "@angular/compiler": "9.0.5", ++ "@babel/code-frame": "7.8.0", ++ "@babel/parser": "7.9.3", ++ "@glimmer/syntax": "0.48.0", ++ "@iarna/toml": "2.2.3", ++ "@typescript-eslint/typescript-estree": "2.24.0", ++ "angular-estree-parser": "1.3.0", ++ "angular-html-parser": "1.4.0", ++ camelcase: "5.3.1", ++ chalk: "3.0.0", ++ "ci-info": "watson/ci-info#f43f6a1cefff47fb361c88cf4b943fdbcaafe540", ++ "cjk-regex": "2.0.0", ++ cosmiconfig: "6.0.0", ++ dashify: "2.0.0", ++ dedent: "0.7.0", ++ diff: "4.0.2", ++ editorconfig: "0.15.3", ++ "editorconfig-to-prettier": "0.1.1", ++ "escape-string-regexp": "2.0.0", ++ esutils: "2.0.3", ++ "fast-glob": "3.2.2", ++ "find-parent-dir": "0.3.0", ++ "find-project-root": "1.1.1", ++ "flow-parser": "0.121.0", ++ "get-stream": "5.1.0", ++ globby: "11.0.0", ++ graphql: "14.6.0", ++ "html-element-attributes": "2.2.1", ++ "html-styles": "1.0.0", ++ "html-tag-names": "1.1.5", ++ ignore: "4.0.6", ++ "jest-docblock": "25.1.0", ++ "json-stable-stringify": "1.0.1", ++ leven: "3.1.0", ++ "lines-and-columns": "1.1.6", ++ "linguist-languages": "7.9.0", ++ lodash: "4.17.15", ++ mem: "6.0.1", ++ minimatch: "3.0.4", ++ minimist: "1.2.5", ++ "n-readlines": "1.0.0", ++ "please-upgrade-node": "3.2.0", ++ "postcss-less": "3.1.4", ++ "postcss-media-query-parser": "0.2.3", ++ "postcss-scss": "2.0.0", ++ "postcss-selector-parser": "2.2.3", ++ "postcss-values-parser": "2.0.1", ++ "regexp-util": "1.2.2", ++ "remark-math": "1.0.6", ++ "remark-parse": "5.0.0", ++ semver: "7.1.3", ++ srcset: "2.0.1", ++ "string-width": "4.2.0", ++ typescript: "3.8.3", ++ "unicode-regex": "3.0.0", ++ unified: "8.4.2", ++ vnopts: "1.0.2", ++ "yaml-unist-parser": "1.1.1" ++}; ++var devDependencies = { ++ "@babel/core": "7.9.0", ++ "@babel/preset-env": "7.9.0", ++ "@rollup/plugin-alias": "3.0.1", ++ "@rollup/plugin-commonjs": "11.0.2", ++ "@rollup/plugin-json": "4.0.2", ++ "@rollup/plugin-node-resolve": "7.1.1", ++ "@rollup/plugin-replace": "2.3.1", ++ "babel-loader": "8.1.0", ++ benchmark: "2.1.4", ++ "builtin-modules": "3.1.0", ++ codecov: "3.6.5", ++ "cross-env": "7.0.2", ++ cspell: "4.0.55", ++ eslint: "6.8.0", ++ "eslint-config-prettier": "6.10.1", ++ "eslint-formatter-friendly": "7.0.0", ++ "eslint-plugin-import": "2.20.1", ++ "eslint-plugin-prettier": "3.1.2", ++ "eslint-plugin-react": "7.19.0", ++ "eslint-plugin-unicorn": "17.2.0", ++ execa: "4.0.0", ++ jest: "25.1.0", ++ "jest-snapshot-serializer-ansi": "1.0.0", ++ "jest-snapshot-serializer-raw": "1.1.0", ++ "jest-watch-typeahead": "0.4.2", ++ prettier: "2.0.1", ++ rimraf: "3.0.2", ++ rollup: "2.1.0", ++ "rollup-plugin-babel": "4.4.0", ++ "rollup-plugin-node-globals": "1.4.0", ++ "rollup-plugin-terser": "5.3.0", ++ shelljs: "0.8.3", ++ "snapshot-diff": "0.7.0", ++ "strip-ansi": "6.0.0", ++ "synchronous-promise": "2.0.10", ++ tempy: "0.5.0", ++ "terser-webpack-plugin": "2.3.5", ++ webpack: "4.42.0" ++}; ++var scripts = { ++ prepublishOnly: "echo \"Error: must publish from dist/\" && exit 1", ++ "prepare-release": "yarn && yarn build && yarn test:dist", ++ test: "jest", ++ "test:dist": "node ./scripts/test-dist.js", ++ "test:integration": "jest tests_integration", ++ "perf:repeat": "yarn && yarn build && cross-env NODE_ENV=production node ./dist/bin-prettier.js --debug-repeat ${PERF_REPEAT:-1000} --loglevel debug ${PERF_FILE:-./index.js} > /dev/null", ++ "perf:repeat-inspect": "yarn && yarn build && cross-env NODE_ENV=production node --inspect-brk ./dist/bin-prettier.js --debug-repeat ${PERF_REPEAT:-1000} --loglevel debug ${PERF_FILE:-./index.js} > /dev/null", ++ "perf:benchmark": "yarn && yarn build && cross-env NODE_ENV=production node ./dist/bin-prettier.js --debug-benchmark --loglevel debug ${PERF_FILE:-./index.js} > /dev/null", ++ "lint:typecheck": "tsc", ++ "lint:eslint": "cross-env EFF_NO_LINK_RULES=true eslint . --format friendly", ++ "lint:changelog": "node ./scripts/lint-changelog.js", ++ "lint:prettier": "prettier \"**/*.{md,json,yml,html,css}\" --check", ++ "lint:dist": "eslint --no-eslintrc --no-ignore --env=es6,browser --parser-options=ecmaVersion:2016 \"dist/!(bin-prettier|index|third-party).js\"", ++ "lint:spellcheck": "cspell {bin,scripts,src,website}/**/*.js {docs,website/blog,changelog_unreleased}/**/*.md", ++ "lint:deps": "node ./scripts/check-deps.js", ++ build: "node --max-old-space-size=3072 ./scripts/build/build.js", ++ "build-docs": "node ./scripts/build-docs.js" ++}; ++var _package = { ++ name: name, ++ version: version, ++ description: description, ++ bin: bin, ++ repository: repository, ++ homepage: homepage, ++ author: author, ++ license: license, ++ main: main, ++ engines: engines, ++ dependencies: dependencies, ++ devDependencies: devDependencies, ++ scripts: scripts ++}; ++ ++var _package$1 = /*#__PURE__*/Object.freeze({ ++ __proto__: null, ++ name: name, ++ version: version, ++ description: description, ++ bin: bin, ++ repository: repository, ++ homepage: homepage, ++ author: author, ++ license: license, ++ main: main, ++ engines: engines, ++ dependencies: dependencies, ++ devDependencies: devDependencies, ++ scripts: scripts, ++ 'default': _package ++}); ++ ++function Diff() {} ++ ++Diff.prototype = { ++ diff: function diff(oldString, newString) { ++ var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; ++ var callback = options.callback; ++ ++ if (typeof options === 'function') { ++ callback = options; ++ options = {}; ++ } ++ ++ this.options = options; ++ var self = this; ++ ++ function done(value) { ++ if (callback) { ++ setTimeout(function () { ++ callback(undefined, value); ++ }, 0); ++ return true; ++ } else { ++ return value; ++ } ++ } // Allow subclasses to massage the input prior to running ++ ++ ++ oldString = this.castInput(oldString); ++ newString = this.castInput(newString); ++ oldString = this.removeEmpty(this.tokenize(oldString)); ++ newString = this.removeEmpty(this.tokenize(newString)); ++ var newLen = newString.length, ++ oldLen = oldString.length; ++ var editLength = 1; ++ var maxEditLength = newLen + oldLen; ++ var bestPath = [{ ++ newPos: -1, ++ components: [] ++ }]; // Seed editLength = 0, i.e. the content starts with the same values ++ ++ var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0); ++ ++ if (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen) { ++ // Identity per the equality and tokenizer ++ return done([{ ++ value: this.join(newString), ++ count: newString.length ++ }]); ++ } // Main worker method. checks all permutations of a given edit length for acceptance. ++ ++ ++ function execEditLength() { ++ for (var diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) { ++ var basePath = void 0; ++ ++ var addPath = bestPath[diagonalPath - 1], ++ removePath = bestPath[diagonalPath + 1], ++ _oldPos = (removePath ? removePath.newPos : 0) - diagonalPath; ++ ++ if (addPath) { ++ // No one else is going to attempt to use this value, clear it ++ bestPath[diagonalPath - 1] = undefined; ++ } ++ ++ var canAdd = addPath && addPath.newPos + 1 < newLen, ++ canRemove = removePath && 0 <= _oldPos && _oldPos < oldLen; ++ ++ if (!canAdd && !canRemove) { ++ // If this path is a terminal then prune ++ bestPath[diagonalPath] = undefined; ++ continue; ++ } // Select the diagonal that we want to branch from. We select the prior ++ // path whose position in the new string is the farthest from the origin ++ // and does not pass the bounds of the diff graph ++ ++ ++ if (!canAdd || canRemove && addPath.newPos < removePath.newPos) { ++ basePath = clonePath(removePath); ++ self.pushComponent(basePath.components, undefined, true); ++ } else { ++ basePath = addPath; // No need to clone, we've pulled it from the list ++ ++ basePath.newPos++; ++ self.pushComponent(basePath.components, true, undefined); ++ } ++ ++ _oldPos = self.extractCommon(basePath, newString, oldString, diagonalPath); // If we have hit the end of both strings, then we are done ++ ++ if (basePath.newPos + 1 >= newLen && _oldPos + 1 >= oldLen) { ++ return done(buildValues(self, basePath.components, newString, oldString, self.useLongestToken)); ++ } else { ++ // Otherwise track this path as a potential candidate and continue. ++ bestPath[diagonalPath] = basePath; ++ } ++ } ++ ++ editLength++; ++ } // Performs the length of edit iteration. Is a bit fugly as this has to support the ++ // sync and async mode which is never fun. Loops over execEditLength until a value ++ // is produced. ++ ++ ++ if (callback) { ++ (function exec() { ++ setTimeout(function () { ++ // This should not happen, but we want to be safe. ++ ++ /* istanbul ignore next */ ++ if (editLength > maxEditLength) { ++ return callback(); ++ } ++ ++ if (!execEditLength()) { ++ exec(); ++ } ++ }, 0); ++ })(); ++ } else { ++ while (editLength <= maxEditLength) { ++ var ret = execEditLength(); ++ ++ if (ret) { ++ return ret; ++ } ++ } ++ } ++ }, ++ pushComponent: function pushComponent(components, added, removed) { ++ var last = components[components.length - 1]; ++ ++ if (last && last.added === added && last.removed === removed) { ++ // We need to clone here as the component clone operation is just ++ // as shallow array clone ++ components[components.length - 1] = { ++ count: last.count + 1, ++ added: added, ++ removed: removed ++ }; ++ } else { ++ components.push({ ++ count: 1, ++ added: added, ++ removed: removed ++ }); ++ } ++ }, ++ extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath) { ++ var newLen = newString.length, ++ oldLen = oldString.length, ++ newPos = basePath.newPos, ++ oldPos = newPos - diagonalPath, ++ commonCount = 0; ++ ++ while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) { ++ newPos++; ++ oldPos++; ++ commonCount++; ++ } ++ ++ if (commonCount) { ++ basePath.components.push({ ++ count: commonCount ++ }); ++ } ++ ++ basePath.newPos = newPos; ++ return oldPos; ++ }, ++ equals: function equals(left, right) { ++ if (this.options.comparator) { ++ return this.options.comparator(left, right); ++ } else { ++ return left === right || this.options.ignoreCase && left.toLowerCase() === right.toLowerCase(); ++ } ++ }, ++ removeEmpty: function removeEmpty(array) { ++ var ret = []; ++ ++ for (var i = 0; i < array.length; i++) { ++ if (array[i]) { ++ ret.push(array[i]); ++ } ++ } ++ ++ return ret; ++ }, ++ castInput: function castInput(value) { ++ return value; ++ }, ++ tokenize: function tokenize(value) { ++ return value.split(''); ++ }, ++ join: function join(chars) { ++ return chars.join(''); ++ } ++}; ++ ++function buildValues(diff, components, newString, oldString, useLongestToken) { ++ var componentPos = 0, ++ componentLen = components.length, ++ newPos = 0, ++ oldPos = 0; ++ ++ for (; componentPos < componentLen; componentPos++) { ++ var component = components[componentPos]; ++ ++ if (!component.removed) { ++ if (!component.added && useLongestToken) { ++ var value = newString.slice(newPos, newPos + component.count); ++ value = value.map(function (value, i) { ++ var oldValue = oldString[oldPos + i]; ++ return oldValue.length > value.length ? oldValue : value; ++ }); ++ component.value = diff.join(value); ++ } else { ++ component.value = diff.join(newString.slice(newPos, newPos + component.count)); ++ } ++ ++ newPos += component.count; // Common case ++ ++ if (!component.added) { ++ oldPos += component.count; ++ } ++ } else { ++ component.value = diff.join(oldString.slice(oldPos, oldPos + component.count)); ++ oldPos += component.count; // Reverse add and remove so removes are output first to match common convention ++ // The diffing algorithm is tied to add then remove output and this is the simplest ++ // route to get the desired output with minimal overhead. ++ ++ if (componentPos && components[componentPos - 1].added) { ++ var tmp = components[componentPos - 1]; ++ components[componentPos - 1] = components[componentPos]; ++ components[componentPos] = tmp; ++ } ++ } ++ } // Special case handle for when one terminal is ignored (i.e. whitespace). ++ // For this case we merge the terminal into the prior string and drop the change. ++ // This is only available for string mode. ++ ++ ++ var lastComponent = components[componentLen - 1]; ++ ++ if (componentLen > 1 && typeof lastComponent.value === 'string' && (lastComponent.added || lastComponent.removed) && diff.equals('', lastComponent.value)) { ++ components[componentLen - 2].value += lastComponent.value; ++ components.pop(); ++ } ++ ++ return components; ++} ++ ++function clonePath(path) { ++ return { ++ newPos: path.newPos, ++ components: path.components.slice(0) ++ }; ++} ++ ++var characterDiff = new Diff(); ++ ++function diffChars(oldStr, newStr, options) { ++ return characterDiff.diff(oldStr, newStr, options); ++} ++ ++function generateOptions(options, defaults) { ++ if (typeof options === 'function') { ++ defaults.callback = options; ++ } else if (options) { ++ for (var name in options) { ++ /* istanbul ignore else */ ++ if (options.hasOwnProperty(name)) { ++ defaults[name] = options[name]; ++ } ++ } ++ } ++ ++ return defaults; ++} // ++// Ranges and exceptions: ++// Latin-1 Supplement, 0080–00FF ++// - U+00D7 × Multiplication sign ++// - U+00F7 ÷ Division sign ++// Latin Extended-A, 0100–017F ++// Latin Extended-B, 0180–024F ++// IPA Extensions, 0250–02AF ++// Spacing Modifier Letters, 02B0–02FF ++// - U+02C7 ˇ ˇ Caron ++// - U+02D8 ˘ ˘ Breve ++// - U+02D9 ˙ ˙ Dot Above ++// - U+02DA ˚ ˚ Ring Above ++// - U+02DB ˛ ˛ Ogonek ++// - U+02DC ˜ ˜ Small Tilde ++// - U+02DD ˝ ˝ Double Acute Accent ++// Latin Extended Additional, 1E00–1EFF ++ ++ ++var extendedWordChars = /^[A-Za-z\xC0-\u02C6\u02C8-\u02D7\u02DE-\u02FF\u1E00-\u1EFF]+$/; ++var reWhitespace = /\S/; ++var wordDiff = new Diff(); ++ ++wordDiff.equals = function (left, right) { ++ if (this.options.ignoreCase) { ++ left = left.toLowerCase(); ++ right = right.toLowerCase(); ++ } ++ ++ return left === right || this.options.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right); ++}; ++ ++wordDiff.tokenize = function (value) { ++ var tokens = value.split(/(\s+|[()[\]{}'"]|\b)/); // Join the boundary splits that we do not consider to be boundaries. This is primarily the extended Latin character set. ++ ++ for (var i = 0; i < tokens.length - 1; i++) { ++ // If we have an empty string in the next field and we have only word chars before and after, merge ++ if (!tokens[i + 1] && tokens[i + 2] && extendedWordChars.test(tokens[i]) && extendedWordChars.test(tokens[i + 2])) { ++ tokens[i] += tokens[i + 2]; ++ tokens.splice(i + 1, 2); ++ i--; ++ } ++ } ++ ++ return tokens; ++}; ++ ++function diffWords(oldStr, newStr, options) { ++ options = generateOptions(options, { ++ ignoreWhitespace: true ++ }); ++ return wordDiff.diff(oldStr, newStr, options); ++} ++ ++function diffWordsWithSpace(oldStr, newStr, options) { ++ return wordDiff.diff(oldStr, newStr, options); ++} ++ ++var lineDiff = new Diff(); ++ ++lineDiff.tokenize = function (value) { ++ var retLines = [], ++ linesAndNewlines = value.split(/(\n|\r\n)/); // Ignore the final empty token that occurs if the string ends with a new line ++ ++ if (!linesAndNewlines[linesAndNewlines.length - 1]) { ++ linesAndNewlines.pop(); ++ } // Merge the content and line separators into single tokens ++ ++ ++ for (var i = 0; i < linesAndNewlines.length; i++) { ++ var line = linesAndNewlines[i]; ++ ++ if (i % 2 && !this.options.newlineIsToken) { ++ retLines[retLines.length - 1] += line; ++ } else { ++ if (this.options.ignoreWhitespace) { ++ line = line.trim(); ++ } ++ ++ retLines.push(line); ++ } ++ } ++ ++ return retLines; ++}; ++ ++function diffLines(oldStr, newStr, callback) { ++ return lineDiff.diff(oldStr, newStr, callback); ++} ++ ++function diffTrimmedLines(oldStr, newStr, callback) { ++ var options = generateOptions(callback, { ++ ignoreWhitespace: true ++ }); ++ return lineDiff.diff(oldStr, newStr, options); ++} ++ ++var sentenceDiff = new Diff(); ++ ++sentenceDiff.tokenize = function (value) { ++ return value.split(/(\S.+?[.!?])(?=\s+|$)/); ++}; ++ ++function diffSentences(oldStr, newStr, callback) { ++ return sentenceDiff.diff(oldStr, newStr, callback); ++} ++ ++var cssDiff = new Diff(); ++ ++cssDiff.tokenize = function (value) { ++ return value.split(/([{}:;,]|\s+)/); ++}; ++ ++function diffCss(oldStr, newStr, callback) { ++ return cssDiff.diff(oldStr, newStr, callback); ++} ++ ++function _typeof(obj) { ++ if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { ++ _typeof = function (obj) { ++ return typeof obj; ++ }; ++ } else { ++ _typeof = function (obj) { ++ return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; ++ }; ++ } ++ ++ return _typeof(obj); ++} ++ ++function _toConsumableArray(arr) { ++ return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); ++} ++ ++function _arrayWithoutHoles(arr) { ++ if (Array.isArray(arr)) { ++ for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; ++ ++ return arr2; ++ } ++} ++ ++function _iterableToArray(iter) { ++ if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); ++} ++ ++function _nonIterableSpread() { ++ throw new TypeError("Invalid attempt to spread non-iterable instance"); ++} ++ ++var objectPrototypeToString = Object.prototype.toString; ++var jsonDiff = new Diff(); // Discriminate between two lines of pretty-printed, serialized JSON where one of them has a ++// dangling comma and the other doesn't. Turns out including the dangling comma yields the nicest output: ++ ++jsonDiff.useLongestToken = true; ++jsonDiff.tokenize = lineDiff.tokenize; ++ ++jsonDiff.castInput = function (value) { ++ var _this$options = this.options, ++ undefinedReplacement = _this$options.undefinedReplacement, ++ _this$options$stringi = _this$options.stringifyReplacer, ++ stringifyReplacer = _this$options$stringi === void 0 ? function (k, v) { ++ return typeof v === 'undefined' ? undefinedReplacement : v; ++ } : _this$options$stringi; ++ return typeof value === 'string' ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), stringifyReplacer, ' '); ++}; ++ ++jsonDiff.equals = function (left, right) { ++ return Diff.prototype.equals.call(jsonDiff, left.replace(/,([\r\n])/g, '$1'), right.replace(/,([\r\n])/g, '$1')); ++}; ++ ++function diffJson(oldObj, newObj, options) { ++ return jsonDiff.diff(oldObj, newObj, options); ++} // This function handles the presence of circular references by bailing out when encountering an ++// object that is already on the "stack" of items being processed. Accepts an optional replacer ++ ++ ++function canonicalize(obj, stack, replacementStack, replacer, key) { ++ stack = stack || []; ++ replacementStack = replacementStack || []; ++ ++ if (replacer) { ++ obj = replacer(key, obj); ++ } ++ ++ var i; ++ ++ for (i = 0; i < stack.length; i += 1) { ++ if (stack[i] === obj) { ++ return replacementStack[i]; ++ } ++ } ++ ++ var canonicalizedObj; ++ ++ if ('[object Array]' === objectPrototypeToString.call(obj)) { ++ stack.push(obj); ++ canonicalizedObj = new Array(obj.length); ++ replacementStack.push(canonicalizedObj); ++ ++ for (i = 0; i < obj.length; i += 1) { ++ canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, key); ++ } ++ ++ stack.pop(); ++ replacementStack.pop(); ++ return canonicalizedObj; ++ } ++ ++ if (obj && obj.toJSON) { ++ obj = obj.toJSON(); ++ } ++ ++ if (_typeof(obj) === 'object' && obj !== null) { ++ stack.push(obj); ++ canonicalizedObj = {}; ++ replacementStack.push(canonicalizedObj); ++ ++ var sortedKeys = [], ++ _key; ++ ++ for (_key in obj) { ++ /* istanbul ignore else */ ++ if (obj.hasOwnProperty(_key)) { ++ sortedKeys.push(_key); ++ } ++ } ++ ++ sortedKeys.sort(); ++ ++ for (i = 0; i < sortedKeys.length; i += 1) { ++ _key = sortedKeys[i]; ++ canonicalizedObj[_key] = canonicalize(obj[_key], stack, replacementStack, replacer, _key); ++ } ++ ++ stack.pop(); ++ replacementStack.pop(); ++ } else { ++ canonicalizedObj = obj; ++ } ++ ++ return canonicalizedObj; ++} ++ ++var arrayDiff = new Diff(); ++ ++arrayDiff.tokenize = function (value) { ++ return value.slice(); ++}; ++ ++arrayDiff.join = arrayDiff.removeEmpty = function (value) { ++ return value; ++}; ++ ++function diffArrays(oldArr, newArr, callback) { ++ return arrayDiff.diff(oldArr, newArr, callback); ++} ++ ++function parsePatch(uniDiff) { ++ var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; ++ var diffstr = uniDiff.split(/\r\n|[\n\v\f\r\x85]/), ++ delimiters = uniDiff.match(/\r\n|[\n\v\f\r\x85]/g) || [], ++ list = [], ++ i = 0; ++ ++ function parseIndex() { ++ var index = {}; ++ list.push(index); // Parse diff metadata ++ ++ while (i < diffstr.length) { ++ var line = diffstr[i]; // File header found, end parsing diff metadata ++ ++ if (/^(\-\-\-|\+\+\+|@@)\s/.test(line)) { ++ break; ++ } // Diff index ++ ++ ++ var header = /^(?:Index:|diff(?: -r \w+)+)\s+(.+?)\s*$/.exec(line); ++ ++ if (header) { ++ index.index = header[1]; ++ } ++ ++ i++; ++ } // Parse file headers if they are defined. Unified diff requires them, but ++ // there's no technical issues to have an isolated hunk without file header ++ ++ ++ parseFileHeader(index); ++ parseFileHeader(index); // Parse hunks ++ ++ index.hunks = []; ++ ++ while (i < diffstr.length) { ++ var _line = diffstr[i]; ++ ++ if (/^(Index:|diff|\-\-\-|\+\+\+)\s/.test(_line)) { ++ break; ++ } else if (/^@@/.test(_line)) { ++ index.hunks.push(parseHunk()); ++ } else if (_line && options.strict) { ++ // Ignore unexpected content unless in strict mode ++ throw new Error('Unknown line ' + (i + 1) + ' ' + JSON.stringify(_line)); ++ } else { ++ i++; ++ } ++ } ++ } // Parses the --- and +++ headers, if none are found, no lines ++ // are consumed. ++ ++ ++ function parseFileHeader(index) { ++ var fileHeader = /^(---|\+\+\+)\s+(.*)$/.exec(diffstr[i]); ++ ++ if (fileHeader) { ++ var keyPrefix = fileHeader[1] === '---' ? 'old' : 'new'; ++ var data = fileHeader[2].split('\t', 2); ++ var fileName = data[0].replace(/\\\\/g, '\\'); ++ ++ if (/^".*"$/.test(fileName)) { ++ fileName = fileName.substr(1, fileName.length - 2); ++ } ++ ++ index[keyPrefix + 'FileName'] = fileName; ++ index[keyPrefix + 'Header'] = (data[1] || '').trim(); ++ i++; ++ } ++ } // Parses a hunk ++ // This assumes that we are at the start of a hunk. ++ ++ ++ function parseHunk() { ++ var chunkHeaderIndex = i, ++ chunkHeaderLine = diffstr[i++], ++ chunkHeader = chunkHeaderLine.split(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/); ++ var hunk = { ++ oldStart: +chunkHeader[1], ++ oldLines: +chunkHeader[2] || 1, ++ newStart: +chunkHeader[3], ++ newLines: +chunkHeader[4] || 1, ++ lines: [], ++ linedelimiters: [] ++ }; ++ var addCount = 0, ++ removeCount = 0; ++ ++ for (; i < diffstr.length; i++) { ++ // Lines starting with '---' could be mistaken for the "remove line" operation ++ // But they could be the header for the next file. Therefore prune such cases out. ++ if (diffstr[i].indexOf('--- ') === 0 && i + 2 < diffstr.length && diffstr[i + 1].indexOf('+++ ') === 0 && diffstr[i + 2].indexOf('@@') === 0) { ++ break; ++ } ++ ++ var operation = diffstr[i].length == 0 && i != diffstr.length - 1 ? ' ' : diffstr[i][0]; ++ ++ if (operation === '+' || operation === '-' || operation === ' ' || operation === '\\') { ++ hunk.lines.push(diffstr[i]); ++ hunk.linedelimiters.push(delimiters[i] || '\n'); ++ ++ if (operation === '+') { ++ addCount++; ++ } else if (operation === '-') { ++ removeCount++; ++ } else if (operation === ' ') { ++ addCount++; ++ removeCount++; ++ } ++ } else { ++ break; ++ } ++ } // Handle the empty block count case ++ ++ ++ if (!addCount && hunk.newLines === 1) { ++ hunk.newLines = 0; ++ } ++ ++ if (!removeCount && hunk.oldLines === 1) { ++ hunk.oldLines = 0; ++ } // Perform optional sanity checking ++ ++ ++ if (options.strict) { ++ if (addCount !== hunk.newLines) { ++ throw new Error('Added line count did not match for hunk at line ' + (chunkHeaderIndex + 1)); ++ } ++ ++ if (removeCount !== hunk.oldLines) { ++ throw new Error('Removed line count did not match for hunk at line ' + (chunkHeaderIndex + 1)); ++ } ++ } ++ ++ return hunk; ++ } ++ ++ while (i < diffstr.length) { ++ parseIndex(); ++ } ++ ++ return list; ++} // Iterator that traverses in the range of [min, max], stepping ++// by distance from a given start position. I.e. for [0, 4], with ++// start of 2, this will iterate 2, 3, 1, 4, 0. ++ ++ ++function distanceIterator(start, minLine, maxLine) { ++ var wantForward = true, ++ backwardExhausted = false, ++ forwardExhausted = false, ++ localOffset = 1; ++ return function iterator() { ++ if (wantForward && !forwardExhausted) { ++ if (backwardExhausted) { ++ localOffset++; ++ } else { ++ wantForward = false; ++ } // Check if trying to fit beyond text length, and if not, check it fits ++ // after offset location (or desired location on first iteration) ++ ++ ++ if (start + localOffset <= maxLine) { ++ return localOffset; ++ } ++ ++ forwardExhausted = true; ++ } ++ ++ if (!backwardExhausted) { ++ if (!forwardExhausted) { ++ wantForward = true; ++ } // Check if trying to fit before text beginning, and if not, check it fits ++ // before offset location ++ ++ ++ if (minLine <= start - localOffset) { ++ return -localOffset++; ++ } ++ ++ backwardExhausted = true; ++ return iterator(); ++ } // We tried to fit hunk before text beginning and beyond text length, then ++ // hunk can't fit on the text. Return undefined ++ ++ }; ++} ++ ++function applyPatch(source, uniDiff) { ++ var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; ++ ++ if (typeof uniDiff === 'string') { ++ uniDiff = parsePatch(uniDiff); ++ } ++ ++ if (Array.isArray(uniDiff)) { ++ if (uniDiff.length > 1) { ++ throw new Error('applyPatch only works with a single input.'); ++ } ++ ++ uniDiff = uniDiff[0]; ++ } // Apply the diff to the input ++ ++ ++ var lines = source.split(/\r\n|[\n\v\f\r\x85]/), ++ delimiters = source.match(/\r\n|[\n\v\f\r\x85]/g) || [], ++ hunks = uniDiff.hunks, ++ compareLine = options.compareLine || function (lineNumber, line, operation, patchContent) { ++ return line === patchContent; ++ }, ++ errorCount = 0, ++ fuzzFactor = options.fuzzFactor || 0, ++ minLine = 0, ++ offset = 0, ++ removeEOFNL, ++ addEOFNL; ++ /** ++ * Checks if the hunk exactly fits on the provided location ++ */ ++ ++ ++ function hunkFits(hunk, toPos) { ++ for (var j = 0; j < hunk.lines.length; j++) { ++ var line = hunk.lines[j], ++ operation = line.length > 0 ? line[0] : ' ', ++ content = line.length > 0 ? line.substr(1) : line; ++ ++ if (operation === ' ' || operation === '-') { ++ // Context sanity check ++ if (!compareLine(toPos + 1, lines[toPos], operation, content)) { ++ errorCount++; ++ ++ if (errorCount > fuzzFactor) { ++ return false; ++ } ++ } ++ ++ toPos++; ++ } ++ } ++ ++ return true; ++ } // Search best fit offsets for each hunk based on the previous ones ++ ++ ++ for (var i = 0; i < hunks.length; i++) { ++ var hunk = hunks[i], ++ maxLine = lines.length - hunk.oldLines, ++ localOffset = 0, ++ toPos = offset + hunk.oldStart - 1; ++ var iterator = distanceIterator(toPos, minLine, maxLine); ++ ++ for (; localOffset !== undefined; localOffset = iterator()) { ++ if (hunkFits(hunk, toPos + localOffset)) { ++ hunk.offset = offset += localOffset; ++ break; ++ } ++ } ++ ++ if (localOffset === undefined) { ++ return false; ++ } // Set lower text limit to end of the current hunk, so next ones don't try ++ // to fit over already patched text ++ ++ ++ minLine = hunk.offset + hunk.oldStart + hunk.oldLines; ++ } // Apply patch hunks ++ ++ ++ var diffOffset = 0; ++ ++ for (var _i = 0; _i < hunks.length; _i++) { ++ var _hunk = hunks[_i], ++ _toPos = _hunk.oldStart + _hunk.offset + diffOffset - 1; ++ ++ diffOffset += _hunk.newLines - _hunk.oldLines; ++ ++ if (_toPos < 0) { ++ // Creating a new file ++ _toPos = 0; ++ } ++ ++ for (var j = 0; j < _hunk.lines.length; j++) { ++ var line = _hunk.lines[j], ++ operation = line.length > 0 ? line[0] : ' ', ++ content = line.length > 0 ? line.substr(1) : line, ++ delimiter = _hunk.linedelimiters[j]; ++ ++ if (operation === ' ') { ++ _toPos++; ++ } else if (operation === '-') { ++ lines.splice(_toPos, 1); ++ delimiters.splice(_toPos, 1); ++ /* istanbul ignore else */ ++ } else if (operation === '+') { ++ lines.splice(_toPos, 0, content); ++ delimiters.splice(_toPos, 0, delimiter); ++ _toPos++; ++ } else if (operation === '\\') { ++ var previousOperation = _hunk.lines[j - 1] ? _hunk.lines[j - 1][0] : null; ++ ++ if (previousOperation === '+') { ++ removeEOFNL = true; ++ } else if (previousOperation === '-') { ++ addEOFNL = true; ++ } ++ } ++ } ++ } // Handle EOFNL insertion/removal ++ ++ ++ if (removeEOFNL) { ++ while (!lines[lines.length - 1]) { ++ lines.pop(); ++ delimiters.pop(); ++ } ++ } else if (addEOFNL) { ++ lines.push(''); ++ delimiters.push('\n'); ++ } ++ ++ for (var _k = 0; _k < lines.length - 1; _k++) { ++ lines[_k] = lines[_k] + delimiters[_k]; ++ } ++ ++ return lines.join(''); ++} // Wrapper that supports multiple file patches via callbacks. ++ ++ ++function applyPatches(uniDiff, options) { ++ if (typeof uniDiff === 'string') { ++ uniDiff = parsePatch(uniDiff); ++ } ++ ++ var currentIndex = 0; ++ ++ function processIndex() { ++ var index = uniDiff[currentIndex++]; ++ ++ if (!index) { ++ return options.complete(); ++ } ++ ++ options.loadFile(index, function (err, data) { ++ if (err) { ++ return options.complete(err); ++ } ++ ++ var updatedContent = applyPatch(data, index, options); ++ options.patched(index, updatedContent, function (err) { ++ if (err) { ++ return options.complete(err); ++ } ++ ++ processIndex(); ++ }); ++ }); ++ } ++ ++ processIndex(); ++} ++ ++function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) { ++ if (!options) { ++ options = {}; ++ } ++ ++ if (typeof options.context === 'undefined') { ++ options.context = 4; ++ } ++ ++ var diff = diffLines(oldStr, newStr, options); ++ diff.push({ ++ value: '', ++ lines: [] ++ }); // Append an empty value to make cleanup easier ++ ++ function contextLines(lines) { ++ return lines.map(function (entry) { ++ return ' ' + entry; ++ }); ++ } ++ ++ var hunks = []; ++ var oldRangeStart = 0, ++ newRangeStart = 0, ++ curRange = [], ++ oldLine = 1, ++ newLine = 1; ++ ++ var _loop = function _loop(i) { ++ var current = diff[i], ++ lines = current.lines || current.value.replace(/\n$/, '').split('\n'); ++ current.lines = lines; ++ ++ if (current.added || current.removed) { ++ var _curRange; // If we have previous context, start with that ++ ++ ++ if (!oldRangeStart) { ++ var prev = diff[i - 1]; ++ oldRangeStart = oldLine; ++ newRangeStart = newLine; ++ ++ if (prev) { ++ curRange = options.context > 0 ? contextLines(prev.lines.slice(-options.context)) : []; ++ oldRangeStart -= curRange.length; ++ newRangeStart -= curRange.length; ++ } ++ } // Output our changes ++ ++ ++ (_curRange = curRange).push.apply(_curRange, _toConsumableArray(lines.map(function (entry) { ++ return (current.added ? '+' : '-') + entry; ++ }))); // Track the updated file position ++ ++ ++ if (current.added) { ++ newLine += lines.length; ++ } else { ++ oldLine += lines.length; ++ } ++ } else { ++ // Identical context lines. Track line changes ++ if (oldRangeStart) { ++ // Close out any changes that have been output (or join overlapping) ++ if (lines.length <= options.context * 2 && i < diff.length - 2) { ++ var _curRange2; // Overlapping ++ ++ ++ (_curRange2 = curRange).push.apply(_curRange2, _toConsumableArray(contextLines(lines))); ++ } else { ++ var _curRange3; // end the range and output ++ ++ ++ var contextSize = Math.min(lines.length, options.context); ++ ++ (_curRange3 = curRange).push.apply(_curRange3, _toConsumableArray(contextLines(lines.slice(0, contextSize)))); ++ ++ var hunk = { ++ oldStart: oldRangeStart, ++ oldLines: oldLine - oldRangeStart + contextSize, ++ newStart: newRangeStart, ++ newLines: newLine - newRangeStart + contextSize, ++ lines: curRange ++ }; ++ ++ if (i >= diff.length - 2 && lines.length <= options.context) { ++ // EOF is inside this hunk ++ var oldEOFNewline = /\n$/.test(oldStr); ++ var newEOFNewline = /\n$/.test(newStr); ++ var noNlBeforeAdds = lines.length == 0 && curRange.length > hunk.oldLines; ++ ++ if (!oldEOFNewline && noNlBeforeAdds) { ++ // special case: old has no eol and no trailing context; no-nl can end up before adds ++ curRange.splice(hunk.oldLines, 0, '\\ No newline at end of file'); ++ } ++ ++ if (!oldEOFNewline && !noNlBeforeAdds || !newEOFNewline) { ++ curRange.push('\\ No newline at end of file'); ++ } ++ } ++ ++ hunks.push(hunk); ++ oldRangeStart = 0; ++ newRangeStart = 0; ++ curRange = []; ++ } ++ } ++ ++ oldLine += lines.length; ++ newLine += lines.length; ++ } ++ }; ++ ++ for (var i = 0; i < diff.length; i++) { ++ _loop(i); ++ } ++ ++ return { ++ oldFileName: oldFileName, ++ newFileName: newFileName, ++ oldHeader: oldHeader, ++ newHeader: newHeader, ++ hunks: hunks ++ }; ++} ++ ++function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) { ++ var diff = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options); ++ var ret = []; ++ ++ if (oldFileName == newFileName) { ++ ret.push('Index: ' + oldFileName); ++ } ++ ++ ret.push('==================================================================='); ++ ret.push('--- ' + diff.oldFileName + (typeof diff.oldHeader === 'undefined' ? '' : '\t' + diff.oldHeader)); ++ ret.push('+++ ' + diff.newFileName + (typeof diff.newHeader === 'undefined' ? '' : '\t' + diff.newHeader)); ++ ++ for (var i = 0; i < diff.hunks.length; i++) { ++ var hunk = diff.hunks[i]; ++ ret.push('@@ -' + hunk.oldStart + ',' + hunk.oldLines + ' +' + hunk.newStart + ',' + hunk.newLines + ' @@'); ++ ret.push.apply(ret, hunk.lines); ++ } ++ ++ return ret.join('\n') + '\n'; ++} ++ ++function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) { ++ return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options); ++} ++ ++function arrayEqual(a, b) { ++ if (a.length !== b.length) { ++ return false; ++ } ++ ++ return arrayStartsWith(a, b); ++} ++ ++function arrayStartsWith(array, start) { ++ if (start.length > array.length) { ++ return false; ++ } ++ ++ for (var i = 0; i < start.length; i++) { ++ if (start[i] !== array[i]) { ++ return false; ++ } ++ } ++ ++ return true; ++} ++ ++function calcLineCount(hunk) { ++ var _calcOldNewLineCount = calcOldNewLineCount(hunk.lines), ++ oldLines = _calcOldNewLineCount.oldLines, ++ newLines = _calcOldNewLineCount.newLines; ++ ++ if (oldLines !== undefined) { ++ hunk.oldLines = oldLines; ++ } else { ++ delete hunk.oldLines; ++ } ++ ++ if (newLines !== undefined) { ++ hunk.newLines = newLines; ++ } else { ++ delete hunk.newLines; ++ } ++} ++ ++function merge(mine, theirs, base) { ++ mine = loadPatch(mine, base); ++ theirs = loadPatch(theirs, base); ++ var ret = {}; // For index we just let it pass through as it doesn't have any necessary meaning. ++ // Leaving sanity checks on this to the API consumer that may know more about the ++ // meaning in their own context. ++ ++ if (mine.index || theirs.index) { ++ ret.index = mine.index || theirs.index; ++ } ++ ++ if (mine.newFileName || theirs.newFileName) { ++ if (!fileNameChanged(mine)) { ++ // No header or no change in ours, use theirs (and ours if theirs does not exist) ++ ret.oldFileName = theirs.oldFileName || mine.oldFileName; ++ ret.newFileName = theirs.newFileName || mine.newFileName; ++ ret.oldHeader = theirs.oldHeader || mine.oldHeader; ++ ret.newHeader = theirs.newHeader || mine.newHeader; ++ } else if (!fileNameChanged(theirs)) { ++ // No header or no change in theirs, use ours ++ ret.oldFileName = mine.oldFileName; ++ ret.newFileName = mine.newFileName; ++ ret.oldHeader = mine.oldHeader; ++ ret.newHeader = mine.newHeader; ++ } else { ++ // Both changed... figure it out ++ ret.oldFileName = selectField(ret, mine.oldFileName, theirs.oldFileName); ++ ret.newFileName = selectField(ret, mine.newFileName, theirs.newFileName); ++ ret.oldHeader = selectField(ret, mine.oldHeader, theirs.oldHeader); ++ ret.newHeader = selectField(ret, mine.newHeader, theirs.newHeader); ++ } ++ } ++ ++ ret.hunks = []; ++ var mineIndex = 0, ++ theirsIndex = 0, ++ mineOffset = 0, ++ theirsOffset = 0; ++ ++ while (mineIndex < mine.hunks.length || theirsIndex < theirs.hunks.length) { ++ var mineCurrent = mine.hunks[mineIndex] || { ++ oldStart: Infinity ++ }, ++ theirsCurrent = theirs.hunks[theirsIndex] || { ++ oldStart: Infinity ++ }; ++ ++ if (hunkBefore(mineCurrent, theirsCurrent)) { ++ // This patch does not overlap with any of the others, yay. ++ ret.hunks.push(cloneHunk(mineCurrent, mineOffset)); ++ mineIndex++; ++ theirsOffset += mineCurrent.newLines - mineCurrent.oldLines; ++ } else if (hunkBefore(theirsCurrent, mineCurrent)) { ++ // This patch does not overlap with any of the others, yay. ++ ret.hunks.push(cloneHunk(theirsCurrent, theirsOffset)); ++ theirsIndex++; ++ mineOffset += theirsCurrent.newLines - theirsCurrent.oldLines; ++ } else { ++ // Overlap, merge as best we can ++ var mergedHunk = { ++ oldStart: Math.min(mineCurrent.oldStart, theirsCurrent.oldStart), ++ oldLines: 0, ++ newStart: Math.min(mineCurrent.newStart + mineOffset, theirsCurrent.oldStart + theirsOffset), ++ newLines: 0, ++ lines: [] ++ }; ++ mergeLines(mergedHunk, mineCurrent.oldStart, mineCurrent.lines, theirsCurrent.oldStart, theirsCurrent.lines); ++ theirsIndex++; ++ mineIndex++; ++ ret.hunks.push(mergedHunk); ++ } ++ } ++ ++ return ret; ++} ++ ++function loadPatch(param, base) { ++ if (typeof param === 'string') { ++ if (/^@@/m.test(param) || /^Index:/m.test(param)) { ++ return parsePatch(param)[0]; ++ } ++ ++ if (!base) { ++ throw new Error('Must provide a base reference or pass in a patch'); ++ } ++ ++ return structuredPatch(undefined, undefined, base, param); ++ } ++ ++ return param; ++} ++ ++function fileNameChanged(patch) { ++ return patch.newFileName && patch.newFileName !== patch.oldFileName; ++} ++ ++function selectField(index, mine, theirs) { ++ if (mine === theirs) { ++ return mine; ++ } else { ++ index.conflict = true; ++ return { ++ mine: mine, ++ theirs: theirs ++ }; ++ } ++} ++ ++function hunkBefore(test, check) { ++ return test.oldStart < check.oldStart && test.oldStart + test.oldLines < check.oldStart; ++} ++ ++function cloneHunk(hunk, offset) { ++ return { ++ oldStart: hunk.oldStart, ++ oldLines: hunk.oldLines, ++ newStart: hunk.newStart + offset, ++ newLines: hunk.newLines, ++ lines: hunk.lines ++ }; ++} ++ ++function mergeLines(hunk, mineOffset, mineLines, theirOffset, theirLines) { ++ // This will generally result in a conflicted hunk, but there are cases where the context ++ // is the only overlap where we can successfully merge the content here. ++ var mine = { ++ offset: mineOffset, ++ lines: mineLines, ++ index: 0 ++ }, ++ their = { ++ offset: theirOffset, ++ lines: theirLines, ++ index: 0 ++ }; // Handle any leading content ++ ++ insertLeading(hunk, mine, their); ++ insertLeading(hunk, their, mine); // Now in the overlap content. Scan through and select the best changes from each. ++ ++ while (mine.index < mine.lines.length && their.index < their.lines.length) { ++ var mineCurrent = mine.lines[mine.index], ++ theirCurrent = their.lines[their.index]; ++ ++ if ((mineCurrent[0] === '-' || mineCurrent[0] === '+') && (theirCurrent[0] === '-' || theirCurrent[0] === '+')) { ++ // Both modified ... ++ mutualChange(hunk, mine, their); ++ } else if (mineCurrent[0] === '+' && theirCurrent[0] === ' ') { ++ var _hunk$lines; // Mine inserted ++ ++ ++ (_hunk$lines = hunk.lines).push.apply(_hunk$lines, _toConsumableArray(collectChange(mine))); ++ } else if (theirCurrent[0] === '+' && mineCurrent[0] === ' ') { ++ var _hunk$lines2; // Theirs inserted ++ ++ ++ (_hunk$lines2 = hunk.lines).push.apply(_hunk$lines2, _toConsumableArray(collectChange(their))); ++ } else if (mineCurrent[0] === '-' && theirCurrent[0] === ' ') { ++ // Mine removed or edited ++ removal(hunk, mine, their); ++ } else if (theirCurrent[0] === '-' && mineCurrent[0] === ' ') { ++ // Their removed or edited ++ removal(hunk, their, mine, true); ++ } else if (mineCurrent === theirCurrent) { ++ // Context identity ++ hunk.lines.push(mineCurrent); ++ mine.index++; ++ their.index++; ++ } else { ++ // Context mismatch ++ conflict(hunk, collectChange(mine), collectChange(their)); ++ } ++ } // Now push anything that may be remaining ++ ++ ++ insertTrailing(hunk, mine); ++ insertTrailing(hunk, their); ++ calcLineCount(hunk); ++} ++ ++function mutualChange(hunk, mine, their) { ++ var myChanges = collectChange(mine), ++ theirChanges = collectChange(their); ++ ++ if (allRemoves(myChanges) && allRemoves(theirChanges)) { ++ // Special case for remove changes that are supersets of one another ++ if (arrayStartsWith(myChanges, theirChanges) && skipRemoveSuperset(their, myChanges, myChanges.length - theirChanges.length)) { ++ var _hunk$lines3; ++ ++ (_hunk$lines3 = hunk.lines).push.apply(_hunk$lines3, _toConsumableArray(myChanges)); ++ ++ return; ++ } else if (arrayStartsWith(theirChanges, myChanges) && skipRemoveSuperset(mine, theirChanges, theirChanges.length - myChanges.length)) { ++ var _hunk$lines4; ++ ++ (_hunk$lines4 = hunk.lines).push.apply(_hunk$lines4, _toConsumableArray(theirChanges)); ++ ++ return; ++ } ++ } else if (arrayEqual(myChanges, theirChanges)) { ++ var _hunk$lines5; ++ ++ (_hunk$lines5 = hunk.lines).push.apply(_hunk$lines5, _toConsumableArray(myChanges)); ++ ++ return; ++ } ++ ++ conflict(hunk, myChanges, theirChanges); ++} ++ ++function removal(hunk, mine, their, swap) { ++ var myChanges = collectChange(mine), ++ theirChanges = collectContext(their, myChanges); ++ ++ if (theirChanges.merged) { ++ var _hunk$lines6; ++ ++ (_hunk$lines6 = hunk.lines).push.apply(_hunk$lines6, _toConsumableArray(theirChanges.merged)); ++ } else { ++ conflict(hunk, swap ? theirChanges : myChanges, swap ? myChanges : theirChanges); ++ } ++} ++ ++function conflict(hunk, mine, their) { ++ hunk.conflict = true; ++ hunk.lines.push({ ++ conflict: true, ++ mine: mine, ++ theirs: their ++ }); ++} ++ ++function insertLeading(hunk, insert, their) { ++ while (insert.offset < their.offset && insert.index < insert.lines.length) { ++ var line = insert.lines[insert.index++]; ++ hunk.lines.push(line); ++ insert.offset++; ++ } ++} ++ ++function insertTrailing(hunk, insert) { ++ while (insert.index < insert.lines.length) { ++ var line = insert.lines[insert.index++]; ++ hunk.lines.push(line); ++ } ++} ++ ++function collectChange(state) { ++ var ret = [], ++ operation = state.lines[state.index][0]; ++ ++ while (state.index < state.lines.length) { ++ var line = state.lines[state.index]; // Group additions that are immediately after subtractions and treat them as one "atomic" modify change. ++ ++ if (operation === '-' && line[0] === '+') { ++ operation = '+'; ++ } ++ ++ if (operation === line[0]) { ++ ret.push(line); ++ state.index++; ++ } else { ++ break; ++ } ++ } ++ ++ return ret; ++} ++ ++function collectContext(state, matchChanges) { ++ var changes = [], ++ merged = [], ++ matchIndex = 0, ++ contextChanges = false, ++ conflicted = false; ++ ++ while (matchIndex < matchChanges.length && state.index < state.lines.length) { ++ var change = state.lines[state.index], ++ match = matchChanges[matchIndex]; // Once we've hit our add, then we are done ++ ++ if (match[0] === '+') { ++ break; ++ } ++ ++ contextChanges = contextChanges || change[0] !== ' '; ++ merged.push(match); ++ matchIndex++; // Consume any additions in the other block as a conflict to attempt ++ // to pull in the remaining context after this ++ ++ if (change[0] === '+') { ++ conflicted = true; ++ ++ while (change[0] === '+') { ++ changes.push(change); ++ change = state.lines[++state.index]; ++ } ++ } ++ ++ if (match.substr(1) === change.substr(1)) { ++ changes.push(change); ++ state.index++; ++ } else { ++ conflicted = true; ++ } ++ } ++ ++ if ((matchChanges[matchIndex] || '')[0] === '+' && contextChanges) { ++ conflicted = true; ++ } ++ ++ if (conflicted) { ++ return changes; ++ } ++ ++ while (matchIndex < matchChanges.length) { ++ merged.push(matchChanges[matchIndex++]); ++ } ++ ++ return { ++ merged: merged, ++ changes: changes ++ }; ++} ++ ++function allRemoves(changes) { ++ return changes.reduce(function (prev, change) { ++ return prev && change[0] === '-'; ++ }, true); ++} ++ ++function skipRemoveSuperset(state, removeChanges, delta) { ++ for (var i = 0; i < delta; i++) { ++ var changeContent = removeChanges[removeChanges.length - delta + i].substr(1); ++ ++ if (state.lines[state.index + i] !== ' ' + changeContent) { ++ return false; ++ } ++ } ++ ++ state.index += delta; ++ return true; ++} ++ ++function calcOldNewLineCount(lines) { ++ var oldLines = 0; ++ var newLines = 0; ++ lines.forEach(function (line) { ++ if (typeof line !== 'string') { ++ var myCount = calcOldNewLineCount(line.mine); ++ var theirCount = calcOldNewLineCount(line.theirs); ++ ++ if (oldLines !== undefined) { ++ if (myCount.oldLines === theirCount.oldLines) { ++ oldLines += myCount.oldLines; ++ } else { ++ oldLines = undefined; ++ } ++ } ++ ++ if (newLines !== undefined) { ++ if (myCount.newLines === theirCount.newLines) { ++ newLines += myCount.newLines; ++ } else { ++ newLines = undefined; ++ } ++ } ++ } else { ++ if (newLines !== undefined && (line[0] === '+' || line[0] === ' ')) { ++ newLines++; ++ } ++ ++ if (oldLines !== undefined && (line[0] === '-' || line[0] === ' ')) { ++ oldLines++; ++ } ++ } ++ }); ++ return { ++ oldLines: oldLines, ++ newLines: newLines ++ }; ++} // See: http://code.google.com/p/google-diff-match-patch/wiki/API ++ ++ ++function convertChangesToDMP(changes) { ++ var ret = [], ++ change, ++ operation; ++ ++ for (var i = 0; i < changes.length; i++) { ++ change = changes[i]; ++ ++ if (change.added) { ++ operation = 1; ++ } else if (change.removed) { ++ operation = -1; ++ } else { ++ operation = 0; ++ } ++ ++ ret.push([operation, change.value]); ++ } ++ ++ return ret; ++} ++ ++function convertChangesToXML(changes) { ++ var ret = []; ++ ++ for (var i = 0; i < changes.length; i++) { ++ var change = changes[i]; ++ ++ if (change.added) { ++ ret.push(''); ++ } else if (change.removed) { ++ ret.push(''); ++ } ++ ++ ret.push(escapeHTML(change.value)); ++ ++ if (change.added) { ++ ret.push(''); ++ } else if (change.removed) { ++ ret.push(''); ++ } ++ } ++ ++ return ret.join(''); ++} ++ ++function escapeHTML(s) { ++ var n = s; ++ n = n.replace(/&/g, '&'); ++ n = n.replace(//g, '>'); ++ n = n.replace(/"/g, '"'); ++ return n; ++} ++ ++var index_es6 = /*#__PURE__*/Object.freeze({ ++ __proto__: null, ++ Diff: Diff, ++ diffChars: diffChars, ++ diffWords: diffWords, ++ diffWordsWithSpace: diffWordsWithSpace, ++ diffLines: diffLines, ++ diffTrimmedLines: diffTrimmedLines, ++ diffSentences: diffSentences, ++ diffCss: diffCss, ++ diffJson: diffJson, ++ diffArrays: diffArrays, ++ structuredPatch: structuredPatch, ++ createTwoFilesPatch: createTwoFilesPatch, ++ createPatch: createPatch, ++ applyPatch: applyPatch, ++ applyPatches: applyPatches, ++ parsePatch: parsePatch, ++ merge: merge, ++ convertChangesToDMP: convertChangesToDMP, ++ convertChangesToXML: convertChangesToXML, ++ canonicalize: canonicalize ++}); ++ ++/** ++ * @class ++ */ ++ ++ ++class LineByLine { ++ constructor(file, options) { ++ options = options || {}; ++ if (!options.readChunk) options.readChunk = 1024; ++ ++ if (!options.newLineCharacter) { ++ options.newLineCharacter = 0x0a; //linux line ending ++ } else { ++ options.newLineCharacter = options.newLineCharacter.charCodeAt(0); ++ } ++ ++ if (typeof file === 'number') { ++ this.fd = file; ++ } else { ++ this.fd = fs$2.openSync(file, 'r'); ++ } ++ ++ this.options = options; ++ this.newLineCharacter = options.newLineCharacter; ++ this.reset(); ++ } ++ ++ _searchInBuffer(buffer, hexNeedle) { ++ let found = -1; ++ ++ for (let i = 0; i <= buffer.length; i++) { ++ let b_byte = buffer[i]; ++ ++ if (b_byte === hexNeedle) { ++ found = i; ++ break; ++ } ++ } ++ ++ return found; ++ } ++ ++ reset() { ++ this.eofReached = false; ++ this.linesCache = []; ++ this.fdPosition = 0; ++ } ++ ++ close() { ++ fs$2.closeSync(this.fd); ++ this.fd = null; ++ } ++ ++ _extractLines(buffer) { ++ let line; ++ const lines = []; ++ let bufferPosition = 0; ++ let lastNewLineBufferPosition = 0; ++ ++ while (true) { ++ let bufferPositionValue = buffer[bufferPosition++]; ++ ++ if (bufferPositionValue === this.newLineCharacter) { ++ line = buffer.slice(lastNewLineBufferPosition, bufferPosition); ++ lines.push(line); ++ lastNewLineBufferPosition = bufferPosition; ++ } else if (!bufferPositionValue) { ++ break; ++ } ++ } ++ ++ let leftovers = buffer.slice(lastNewLineBufferPosition, bufferPosition); ++ ++ if (leftovers.length) { ++ lines.push(leftovers); ++ } ++ ++ return lines; ++ } ++ ++ _readChunk(lineLeftovers) { ++ let totalBytesRead = 0; ++ let bytesRead; ++ const buffers = []; ++ ++ do { ++ const readBuffer = new Buffer(this.options.readChunk); ++ bytesRead = fs$2.readSync(this.fd, readBuffer, 0, this.options.readChunk, this.fdPosition); ++ totalBytesRead = totalBytesRead + bytesRead; ++ this.fdPosition = this.fdPosition + bytesRead; ++ buffers.push(readBuffer); ++ } while (bytesRead && this._searchInBuffer(buffers[buffers.length - 1], this.options.newLineCharacter) === -1); ++ ++ let bufferData = Buffer.concat(buffers); ++ ++ if (bytesRead < this.options.readChunk) { ++ this.eofReached = true; ++ bufferData = bufferData.slice(0, totalBytesRead); ++ } ++ ++ if (totalBytesRead) { ++ this.linesCache = this._extractLines(bufferData); ++ ++ if (lineLeftovers) { ++ this.linesCache[0] = Buffer.concat([lineLeftovers, this.linesCache[0]]); ++ } ++ } ++ ++ return totalBytesRead; ++ } ++ ++ next() { ++ if (!this.fd) return false; ++ let line = false; ++ ++ if (this.eofReached && this.linesCache.length === 0) { ++ return line; ++ } ++ ++ let bytesRead; ++ ++ if (!this.linesCache.length) { ++ bytesRead = this._readChunk(); ++ } ++ ++ if (this.linesCache.length) { ++ line = this.linesCache.shift(); ++ const lastLineCharacter = line[line.length - 1]; ++ ++ if (lastLineCharacter !== 0x0a) { ++ bytesRead = this._readChunk(line); ++ ++ if (bytesRead) { ++ line = this.linesCache.shift(); ++ } ++ } ++ } ++ ++ if (this.eofReached && this.linesCache.length === 0) { ++ this.close(); ++ } ++ ++ if (line && line[line.length - 1] === this.newLineCharacter) { ++ line = line.slice(0, line.length - 1); ++ } ++ ++ return line; ++ } ++ ++} ++ ++var readlines = LineByLine; ++ ++/** ++ * The inverse of `_.toPairs`; this method returns an object composed ++ * from key-value `pairs`. ++ * ++ * @static ++ * @memberOf _ ++ * @since 4.0.0 ++ * @category Array ++ * @param {Array} pairs The key-value pairs. ++ * @returns {Object} Returns the new object. ++ * @example ++ * ++ * _.fromPairs([['a', 1], ['b', 2]]); ++ * // => { 'a': 1, 'b': 2 } ++ */ ++function fromPairs(pairs) { ++ var index = -1, ++ length = pairs == null ? 0 : pairs.length, ++ result = {}; ++ ++ while (++index < length) { ++ var pair = pairs[index]; ++ result[pair[0]] = pair[1]; ++ } ++ ++ return result; ++} ++ ++var fromPairs_1 = fromPairs; ++ ++class ConfigError extends Error {} ++ ++class DebugError extends Error {} ++ ++class UndefinedParserError extends Error {} ++ ++var errors = { ++ ConfigError, ++ DebugError, ++ UndefinedParserError ++}; ++ ++function _objectWithoutPropertiesLoose(source, excluded) { ++ if (source == null) return {}; ++ var target = {}; ++ var sourceKeys = Object.keys(source); ++ var key, i; ++ ++ for (i = 0; i < sourceKeys.length; i++) { ++ key = sourceKeys[i]; ++ if (excluded.indexOf(key) >= 0) continue; ++ target[key] = source[key]; ++ } ++ ++ return target; ++} ++ ++const debug = typeof process === 'object' && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error('SEMVER', ...args) : () => {}; ++var debug_1 = debug; ++ ++// Note: this is the semver.org version of the spec that it implements ++// Not necessarily the package version of this code. ++const SEMVER_SPEC_VERSION = '2.0.0'; ++const MAX_LENGTH = 256; ++const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || ++/* istanbul ignore next */ ++9007199254740991; // Max safe segment length for coercion. ++ ++const MAX_SAFE_COMPONENT_LENGTH = 16; ++var constants = { ++ SEMVER_SPEC_VERSION, ++ MAX_LENGTH, ++ MAX_SAFE_INTEGER, ++ MAX_SAFE_COMPONENT_LENGTH ++}; ++ ++function unwrapExports (x) { ++ return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x; ++} ++ ++function createCommonjsModule(fn, module) { ++ return module = { exports: {} }, fn(module, module.exports), module.exports; ++} ++ ++function getCjsExportFromNamespace (n) { ++ return n && n['default'] || n; ++} ++ ++var re_1 = createCommonjsModule(function (module, exports) { ++ const { ++ MAX_SAFE_COMPONENT_LENGTH ++ } = constants; ++ exports = module.exports = {}; // The actual regexps go on exports.re ++ ++ const re = exports.re = []; ++ const src = exports.src = []; ++ const t = exports.t = {}; ++ let R = 0; ++ ++ const createToken = (name, value, isGlobal) => { ++ const index = R++; ++ debug_1(index, value); ++ t[name] = index; ++ src[index] = value; ++ re[index] = new RegExp(value, isGlobal ? 'g' : undefined); ++ }; // The following Regular Expressions can be used for tokenizing, ++ // validating, and parsing SemVer version strings. ++ // ## Numeric Identifier ++ // A single `0`, or a non-zero digit followed by zero or more digits. ++ ++ ++ createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*'); ++ createToken('NUMERICIDENTIFIERLOOSE', '[0-9]+'); // ## Non-numeric Identifier ++ // Zero or more digits, followed by a letter or hyphen, and then zero or ++ // more letters, digits, or hyphens. ++ ++ createToken('NONNUMERICIDENTIFIER', '\\d*[a-zA-Z-][a-zA-Z0-9-]*'); // ## Main Version ++ // Three dot-separated numeric identifiers. ++ ++ createToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\.` + `(${src[t.NUMERICIDENTIFIER]})\\.` + `(${src[t.NUMERICIDENTIFIER]})`); ++ createToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` + `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` + `(${src[t.NUMERICIDENTIFIERLOOSE]})`); // ## Pre-release Version Identifier ++ // A numeric identifier, or a non-numeric identifier. ++ ++ createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NUMERICIDENTIFIER]}|${src[t.NONNUMERICIDENTIFIER]})`); ++ createToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NUMERICIDENTIFIERLOOSE]}|${src[t.NONNUMERICIDENTIFIER]})`); // ## Pre-release Version ++ // Hyphen, followed by one or more dot-separated pre-release version ++ // identifiers. ++ ++ createToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`); ++ createToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`); // ## Build Metadata Identifier ++ // Any combination of digits, letters, or hyphens. ++ ++ createToken('BUILDIDENTIFIER', '[0-9A-Za-z-]+'); // ## Build Metadata ++ // Plus sign, followed by one or more period-separated build metadata ++ // identifiers. ++ ++ createToken('BUILD', `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`); // ## Full Version String ++ // A main version, followed optionally by a pre-release version and ++ // build metadata. ++ // Note that the only major, minor, patch, and pre-release sections of ++ // the version string are capturing groups. The build metadata is not a ++ // capturing group, because it should not ever be used in version ++ // comparison. ++ ++ createToken('FULLPLAIN', `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`); ++ createToken('FULL', `^${src[t.FULLPLAIN]}$`); // like full, but allows v1.2.3 and =1.2.3, which people do sometimes. ++ // also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty ++ // common in the npm registry. ++ ++ createToken('LOOSEPLAIN', `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`); ++ createToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`); ++ createToken('GTLT', '((?:<|>)?=?)'); // Something like "2.*" or "1.2.x". ++ // Note that "x.x" is a valid xRange identifer, meaning "any version" ++ // Only the first item is strictly required. ++ ++ createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`); ++ createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`); ++ createToken('XRANGEPLAIN', `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` + `(?:\\.(${src[t.XRANGEIDENTIFIER]})` + `(?:\\.(${src[t.XRANGEIDENTIFIER]})` + `(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?` + `)?)?`); ++ createToken('XRANGEPLAINLOOSE', `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?` + `)?)?`); ++ createToken('XRANGE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`); ++ createToken('XRANGELOOSE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`); // Coercion. ++ // Extract anything that could conceivably be a part of a valid semver ++ ++ createToken('COERCE', `${'(^|[^\\d])' + '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` + `(?:$|[^\\d])`); ++ createToken('COERCERTL', src[t.COERCE], true); // Tilde ranges. ++ // Meaning is "reasonably at or greater than" ++ ++ createToken('LONETILDE', '(?:~>?)'); ++ createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true); ++ exports.tildeTrimReplace = '$1~'; ++ createToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`); ++ createToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`); // Caret ranges. ++ // Meaning is "at least and backwards compatible with" ++ ++ createToken('LONECARET', '(?:\\^)'); ++ createToken('CARETTRIM', `(\\s*)${src[t.LONECARET]}\\s+`, true); ++ exports.caretTrimReplace = '$1^'; ++ createToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`); ++ createToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`); // A simple gt/lt/eq thing, or just "" to indicate "any version" ++ ++ createToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`); ++ createToken('COMPARATOR', `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`); // An expression to strip any whitespace between the gtlt and the thing ++ // it modifies, so that `> 1.2.3` ==> `>1.2.3` ++ ++ createToken('COMPARATORTRIM', `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true); ++ exports.comparatorTrimReplace = '$1$2$3'; // Something like `1.2.3 - 1.2.4` ++ // Note that these all use the loose form, because they'll be ++ // checked against either the strict or loose comparator form ++ // later. ++ ++ createToken('HYPHENRANGE', `^\\s*(${src[t.XRANGEPLAIN]})` + `\\s+-\\s+` + `(${src[t.XRANGEPLAIN]})` + `\\s*$`); ++ createToken('HYPHENRANGELOOSE', `^\\s*(${src[t.XRANGEPLAINLOOSE]})` + `\\s+-\\s+` + `(${src[t.XRANGEPLAINLOOSE]})` + `\\s*$`); // Star ranges basically just allow anything at all. ++ ++ createToken('STAR', '(<|>)?=?\\s*\\*'); ++}); ++var re_2 = re_1.re; ++var re_3 = re_1.src; ++var re_4 = re_1.t; ++var re_5 = re_1.tildeTrimReplace; ++var re_6 = re_1.caretTrimReplace; ++var re_7 = re_1.comparatorTrimReplace; ++ ++const numeric = /^[0-9]+$/; ++ ++const compareIdentifiers = (a, b) => { ++ const anum = numeric.test(a); ++ const bnum = numeric.test(b); ++ ++ if (anum && bnum) { ++ a = +a; ++ b = +b; ++ } ++ ++ return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1; ++}; ++ ++const rcompareIdentifiers = (a, b) => compareIdentifiers(b, a); ++ ++var identifiers = { ++ compareIdentifiers, ++ rcompareIdentifiers ++}; ++ ++const { ++ MAX_LENGTH: MAX_LENGTH$1, ++ MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1 ++} = constants; ++const { ++ re, ++ t ++} = re_1; ++const { ++ compareIdentifiers: compareIdentifiers$1 ++} = identifiers; ++ ++class SemVer { ++ constructor(version, options) { ++ if (!options || typeof options !== 'object') { ++ options = { ++ loose: !!options, ++ includePrerelease: false ++ }; ++ } ++ ++ if (version instanceof SemVer) { ++ if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) { ++ return version; ++ } else { ++ version = version.version; ++ } ++ } else if (typeof version !== 'string') { ++ throw new TypeError(`Invalid Version: ${version}`); ++ } ++ ++ if (version.length > MAX_LENGTH$1) { ++ throw new TypeError(`version is longer than ${MAX_LENGTH$1} characters`); ++ } ++ ++ debug_1('SemVer', version, options); ++ this.options = options; ++ this.loose = !!options.loose; // this isn't actually relevant for versions, but keep it so that we ++ // don't run into trouble passing this.options around. ++ ++ this.includePrerelease = !!options.includePrerelease; ++ const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]); ++ ++ if (!m) { ++ throw new TypeError(`Invalid Version: ${version}`); ++ } ++ ++ this.raw = version; // these are actually numbers ++ ++ this.major = +m[1]; ++ this.minor = +m[2]; ++ this.patch = +m[3]; ++ ++ if (this.major > MAX_SAFE_INTEGER$1 || this.major < 0) { ++ throw new TypeError('Invalid major version'); ++ } ++ ++ if (this.minor > MAX_SAFE_INTEGER$1 || this.minor < 0) { ++ throw new TypeError('Invalid minor version'); ++ } ++ ++ if (this.patch > MAX_SAFE_INTEGER$1 || this.patch < 0) { ++ throw new TypeError('Invalid patch version'); ++ } // numberify any prerelease numeric ids ++ ++ ++ if (!m[4]) { ++ this.prerelease = []; ++ } else { ++ this.prerelease = m[4].split('.').map(id => { ++ if (/^[0-9]+$/.test(id)) { ++ const num = +id; ++ ++ if (num >= 0 && num < MAX_SAFE_INTEGER$1) { ++ return num; ++ } ++ } ++ ++ return id; ++ }); ++ } ++ ++ this.build = m[5] ? m[5].split('.') : []; ++ this.format(); ++ } ++ ++ format() { ++ this.version = `${this.major}.${this.minor}.${this.patch}`; ++ ++ if (this.prerelease.length) { ++ this.version += `-${this.prerelease.join('.')}`; ++ } ++ ++ return this.version; ++ } ++ ++ toString() { ++ return this.version; ++ } ++ ++ compare(other) { ++ debug_1('SemVer.compare', this.version, this.options, other); ++ ++ if (!(other instanceof SemVer)) { ++ if (typeof other === 'string' && other === this.version) { ++ return 0; ++ } ++ ++ other = new SemVer(other, this.options); ++ } ++ ++ if (other.version === this.version) { ++ return 0; ++ } ++ ++ return this.compareMain(other) || this.comparePre(other); ++ } ++ ++ compareMain(other) { ++ if (!(other instanceof SemVer)) { ++ other = new SemVer(other, this.options); ++ } ++ ++ return compareIdentifiers$1(this.major, other.major) || compareIdentifiers$1(this.minor, other.minor) || compareIdentifiers$1(this.patch, other.patch); ++ } ++ ++ comparePre(other) { ++ if (!(other instanceof SemVer)) { ++ other = new SemVer(other, this.options); ++ } // NOT having a prerelease is > having one ++ ++ ++ if (this.prerelease.length && !other.prerelease.length) { ++ return -1; ++ } else if (!this.prerelease.length && other.prerelease.length) { ++ return 1; ++ } else if (!this.prerelease.length && !other.prerelease.length) { ++ return 0; ++ } ++ ++ let i = 0; ++ ++ do { ++ const a = this.prerelease[i]; ++ const b = other.prerelease[i]; ++ debug_1('prerelease compare', i, a, b); ++ ++ if (a === undefined && b === undefined) { ++ return 0; ++ } else if (b === undefined) { ++ return 1; ++ } else if (a === undefined) { ++ return -1; ++ } else if (a === b) { ++ continue; ++ } else { ++ return compareIdentifiers$1(a, b); ++ } ++ } while (++i); ++ } ++ ++ compareBuild(other) { ++ if (!(other instanceof SemVer)) { ++ other = new SemVer(other, this.options); ++ } ++ ++ let i = 0; ++ ++ do { ++ const a = this.build[i]; ++ const b = other.build[i]; ++ debug_1('prerelease compare', i, a, b); ++ ++ if (a === undefined && b === undefined) { ++ return 0; ++ } else if (b === undefined) { ++ return 1; ++ } else if (a === undefined) { ++ return -1; ++ } else if (a === b) { ++ continue; ++ } else { ++ return compareIdentifiers$1(a, b); ++ } ++ } while (++i); ++ } // preminor will bump the version up to the next minor release, and immediately ++ // down to pre-release. premajor and prepatch work the same way. ++ ++ ++ inc(release, identifier) { ++ switch (release) { ++ case 'premajor': ++ this.prerelease.length = 0; ++ this.patch = 0; ++ this.minor = 0; ++ this.major++; ++ this.inc('pre', identifier); ++ break; ++ ++ case 'preminor': ++ this.prerelease.length = 0; ++ this.patch = 0; ++ this.minor++; ++ this.inc('pre', identifier); ++ break; ++ ++ case 'prepatch': ++ // If this is already a prerelease, it will bump to the next version ++ // drop any prereleases that might already exist, since they are not ++ // relevant at this point. ++ this.prerelease.length = 0; ++ this.inc('patch', identifier); ++ this.inc('pre', identifier); ++ break; ++ // If the input is a non-prerelease version, this acts the same as ++ // prepatch. ++ ++ case 'prerelease': ++ if (this.prerelease.length === 0) { ++ this.inc('patch', identifier); ++ } ++ ++ this.inc('pre', identifier); ++ break; ++ ++ case 'major': ++ // If this is a pre-major version, bump up to the same major version. ++ // Otherwise increment major. ++ // 1.0.0-5 bumps to 1.0.0 ++ // 1.1.0 bumps to 2.0.0 ++ if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) { ++ this.major++; ++ } ++ ++ this.minor = 0; ++ this.patch = 0; ++ this.prerelease = []; ++ break; ++ ++ case 'minor': ++ // If this is a pre-minor version, bump up to the same minor version. ++ // Otherwise increment minor. ++ // 1.2.0-5 bumps to 1.2.0 ++ // 1.2.1 bumps to 1.3.0 ++ if (this.patch !== 0 || this.prerelease.length === 0) { ++ this.minor++; ++ } ++ ++ this.patch = 0; ++ this.prerelease = []; ++ break; ++ ++ case 'patch': ++ // If this is not a pre-release version, it will increment the patch. ++ // If it is a pre-release it will bump up to the same patch version. ++ // 1.2.0-5 patches to 1.2.0 ++ // 1.2.0 patches to 1.2.1 ++ if (this.prerelease.length === 0) { ++ this.patch++; ++ } ++ ++ this.prerelease = []; ++ break; ++ // This probably shouldn't be used publicly. ++ // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction. ++ ++ case 'pre': ++ if (this.prerelease.length === 0) { ++ this.prerelease = [0]; ++ } else { ++ let i = this.prerelease.length; ++ ++ while (--i >= 0) { ++ if (typeof this.prerelease[i] === 'number') { ++ this.prerelease[i]++; ++ i = -2; ++ } ++ } ++ ++ if (i === -1) { ++ // didn't increment anything ++ this.prerelease.push(0); ++ } ++ } ++ ++ if (identifier) { ++ // 1.2.0-beta.1 bumps to 1.2.0-beta.2, ++ // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0 ++ if (this.prerelease[0] === identifier) { ++ if (isNaN(this.prerelease[1])) { ++ this.prerelease = [identifier, 0]; ++ } ++ } else { ++ this.prerelease = [identifier, 0]; ++ } ++ } ++ ++ break; ++ ++ default: ++ throw new Error(`invalid increment argument: ${release}`); ++ } ++ ++ this.format(); ++ this.raw = this.version; ++ return this; ++ } ++ ++} ++ ++var semver = SemVer; ++ ++const compare = (a, b, loose) => new semver(a, loose).compare(new semver(b, loose)); ++ ++var compare_1 = compare; ++ ++const lt = (a, b, loose) => compare_1(a, b, loose) < 0; ++ ++var lt_1 = lt; ++ ++const gte = (a, b, loose) => compare_1(a, b, loose) >= 0; ++ ++var gte_1 = gte; ++ ++var arrayify = (object, keyName) => Object.entries(object).map(([key, value]) => Object.assign({ ++ [keyName]: key ++}, value)); ++ ++var dedent_1 = createCommonjsModule(function (module) { ++ ++ function dedent(strings) { ++ var raw = void 0; ++ ++ if (typeof strings === "string") { ++ // dedent can be used as a plain function ++ raw = [strings]; ++ } else { ++ raw = strings.raw; ++ } // first, perform interpolation ++ ++ ++ var result = ""; ++ ++ for (var i = 0; i < raw.length; i++) { ++ result += raw[i]. // join lines when there is a suppressed newline ++ replace(/\\\n[ \t]*/g, ""). // handle escaped backticks ++ replace(/\\`/g, "`"); ++ ++ if (i < (arguments.length <= 1 ? 0 : arguments.length - 1)) { ++ result += arguments.length <= i + 1 ? undefined : arguments[i + 1]; ++ } ++ } // now strip indentation ++ ++ ++ var lines = result.split("\n"); ++ var mindent = null; ++ lines.forEach(function (l) { ++ var m = l.match(/^(\s+)\S+/); ++ ++ if (m) { ++ var indent = m[1].length; ++ ++ if (!mindent) { ++ // this is the first indented line ++ mindent = indent; ++ } else { ++ mindent = Math.min(mindent, indent); ++ } ++ } ++ }); ++ ++ if (mindent !== null) { ++ result = lines.map(function (l) { ++ return l[0] === " " ? l.slice(mindent) : l; ++ }).join("\n"); ++ } // dedent eats leading and trailing whitespace too ++ ++ ++ result = result.trim(); // handle escaped newlines at the end to ensure they don't get stripped too ++ ++ return result.replace(/\\n/g, "\n"); ++ } ++ ++ { ++ module.exports = dedent; ++ } ++}); ++ ++const CATEGORY_CONFIG = "Config"; ++const CATEGORY_EDITOR = "Editor"; ++const CATEGORY_FORMAT = "Format"; ++const CATEGORY_OTHER = "Other"; ++const CATEGORY_OUTPUT = "Output"; ++const CATEGORY_GLOBAL = "Global"; ++const CATEGORY_SPECIAL = "Special"; ++/** ++ * @typedef {Object} OptionInfo ++ * @property {string} [since] - available since version ++ * @property {string} category ++ * @property {'int' | 'boolean' | 'choice' | 'path'} type ++ * @property {boolean} [array] - indicate it's an array of the specified type ++ * @property {OptionValueInfo} [default] ++ * @property {OptionRangeInfo} [range] - for type int ++ * @property {string} description ++ * @property {string} [deprecated] - deprecated since version ++ * @property {OptionRedirectInfo} [redirect] - redirect deprecated option ++ * @property {(value: any) => boolean} [exception] ++ * @property {OptionChoiceInfo[]} [choices] - for type choice ++ * @property {string} [cliName] ++ * @property {string} [cliCategory] ++ * @property {string} [cliDescription] ++ * ++ * @typedef {number | boolean | string} OptionValue ++ * @typedef {OptionValue | [{ value: OptionValue[] }] | Array<{ since: string, value: OptionValue}>} OptionValueInfo ++ * ++ * @typedef {Object} OptionRedirectInfo ++ * @property {string} option ++ * @property {OptionValue} value ++ * ++ * @typedef {Object} OptionRangeInfo ++ * @property {number} start - recommended range start ++ * @property {number} end - recommended range end ++ * @property {number} step - recommended range step ++ * ++ * @typedef {Object} OptionChoiceInfo ++ * @property {boolean | string} value - boolean for the option that is originally boolean type ++ * @property {string} description ++ * @property {string} [since] - undefined if available since the first version of the option ++ * @property {string} [deprecated] - deprecated since version ++ * @property {OptionValueInfo} [redirect] - redirect deprecated value ++ */ ++ ++/** @type {{ [name: string]: OptionInfo }} */ ++ ++const options = { ++ cursorOffset: { ++ since: "1.4.0", ++ category: CATEGORY_SPECIAL, ++ type: "int", ++ default: -1, ++ range: { ++ start: -1, ++ end: Infinity, ++ step: 1 ++ }, ++ description: dedent_1` ++ Print (to stderr) where a cursor at the given position would move to after formatting. ++ This option cannot be used with --range-start and --range-end. ++ `, ++ cliCategory: CATEGORY_EDITOR ++ }, ++ endOfLine: { ++ since: "1.15.0", ++ category: CATEGORY_GLOBAL, ++ type: "choice", ++ default: [{ ++ since: "1.15.0", ++ value: "auto" ++ }, { ++ since: "2.0.0", ++ value: "lf" ++ }], ++ description: "Which end of line characters to apply.", ++ choices: [{ ++ value: "lf", ++ description: "Line Feed only (\\n), common on Linux and macOS as well as inside git repos" ++ }, { ++ value: "crlf", ++ description: "Carriage Return + Line Feed characters (\\r\\n), common on Windows" ++ }, { ++ value: "cr", ++ description: "Carriage Return character only (\\r), used very rarely" ++ }, { ++ value: "auto", ++ description: dedent_1` ++ Maintain existing ++ (mixed values within one file are normalised by looking at what's used after the first line) ++ ` ++ }] ++ }, ++ filepath: { ++ since: "1.4.0", ++ category: CATEGORY_SPECIAL, ++ type: "path", ++ description: "Specify the input filepath. This will be used to do parser inference.", ++ cliName: "stdin-filepath", ++ cliCategory: CATEGORY_OTHER, ++ cliDescription: "Path to the file to pretend that stdin comes from." ++ }, ++ insertPragma: { ++ since: "1.8.0", ++ category: CATEGORY_SPECIAL, ++ type: "boolean", ++ default: false, ++ description: "Insert @format pragma into file's first docblock comment.", ++ cliCategory: CATEGORY_OTHER ++ }, ++ parser: { ++ since: "0.0.10", ++ category: CATEGORY_GLOBAL, ++ type: "choice", ++ default: [{ ++ since: "0.0.10", ++ value: "babylon" ++ }, { ++ since: "1.13.0", ++ value: undefined ++ }], ++ description: "Which parser to use.", ++ exception: value => typeof value === "string" || typeof value === "function", ++ choices: [{ ++ value: "flow", ++ description: "Flow" ++ }, { ++ value: "babel", ++ since: "1.16.0", ++ description: "JavaScript" ++ }, { ++ value: "babel-flow", ++ since: "1.16.0", ++ description: "Flow" ++ }, { ++ value: "babel-ts", ++ since: "2.0.0", ++ description: "TypeScript" ++ }, { ++ value: "typescript", ++ since: "1.4.0", ++ description: "TypeScript" ++ }, { ++ value: "css", ++ since: "1.7.1", ++ description: "CSS" ++ }, { ++ value: "less", ++ since: "1.7.1", ++ description: "Less" ++ }, { ++ value: "scss", ++ since: "1.7.1", ++ description: "SCSS" ++ }, { ++ value: "json", ++ since: "1.5.0", ++ description: "JSON" ++ }, { ++ value: "json5", ++ since: "1.13.0", ++ description: "JSON5" ++ }, { ++ value: "json-stringify", ++ since: "1.13.0", ++ description: "JSON.stringify" ++ }, { ++ value: "graphql", ++ since: "1.5.0", ++ description: "GraphQL" ++ }, { ++ value: "markdown", ++ since: "1.8.0", ++ description: "Markdown" ++ }, { ++ value: "mdx", ++ since: "1.15.0", ++ description: "MDX" ++ }, { ++ value: "vue", ++ since: "1.10.0", ++ description: "Vue" ++ }, { ++ value: "yaml", ++ since: "1.14.0", ++ description: "YAML" ++ }, { ++ value: "glimmer", ++ since: null, ++ description: "Handlebars" ++ }, { ++ value: "html", ++ since: "1.15.0", ++ description: "HTML" ++ }, { ++ value: "angular", ++ since: "1.15.0", ++ description: "Angular" ++ }, { ++ value: "lwc", ++ since: "1.17.0", ++ description: "Lightning Web Components" ++ }] ++ }, ++ plugins: { ++ since: "1.10.0", ++ type: "path", ++ array: true, ++ default: [{ ++ value: [] ++ }], ++ category: CATEGORY_GLOBAL, ++ description: "Add a plugin. Multiple plugins can be passed as separate `--plugin`s.", ++ exception: value => typeof value === "string" || typeof value === "object", ++ cliName: "plugin", ++ cliCategory: CATEGORY_CONFIG ++ }, ++ pluginSearchDirs: { ++ since: "1.13.0", ++ type: "path", ++ array: true, ++ default: [{ ++ value: [] ++ }], ++ category: CATEGORY_GLOBAL, ++ description: dedent_1` ++ Custom directory that contains prettier plugins in node_modules subdirectory. ++ Overrides default behavior when plugins are searched relatively to the location of Prettier. ++ Multiple values are accepted. ++ `, ++ exception: value => typeof value === "string" || typeof value === "object", ++ cliName: "plugin-search-dir", ++ cliCategory: CATEGORY_CONFIG ++ }, ++ printWidth: { ++ since: "0.0.0", ++ category: CATEGORY_GLOBAL, ++ type: "int", ++ default: 80, ++ description: "The line length where Prettier will try wrap.", ++ range: { ++ start: 0, ++ end: Infinity, ++ step: 1 ++ } ++ }, ++ rangeEnd: { ++ since: "1.4.0", ++ category: CATEGORY_SPECIAL, ++ type: "int", ++ default: Infinity, ++ range: { ++ start: 0, ++ end: Infinity, ++ step: 1 ++ }, ++ description: dedent_1` ++ Format code ending at a given character offset (exclusive). ++ The range will extend forwards to the end of the selected statement. ++ This option cannot be used with --cursor-offset. ++ `, ++ cliCategory: CATEGORY_EDITOR ++ }, ++ rangeStart: { ++ since: "1.4.0", ++ category: CATEGORY_SPECIAL, ++ type: "int", ++ default: 0, ++ range: { ++ start: 0, ++ end: Infinity, ++ step: 1 ++ }, ++ description: dedent_1` ++ Format code starting at a given character offset. ++ The range will extend backwards to the start of the first line containing the selected statement. ++ This option cannot be used with --cursor-offset. ++ `, ++ cliCategory: CATEGORY_EDITOR ++ }, ++ requirePragma: { ++ since: "1.7.0", ++ category: CATEGORY_SPECIAL, ++ type: "boolean", ++ default: false, ++ description: dedent_1` ++ Require either '@prettier' or '@format' to be present in the file's first docblock comment ++ in order for it to be formatted. ++ `, ++ cliCategory: CATEGORY_OTHER ++ }, ++ tabWidth: { ++ type: "int", ++ category: CATEGORY_GLOBAL, ++ default: 2, ++ description: "Number of spaces per indentation level.", ++ range: { ++ start: 0, ++ end: Infinity, ++ step: 1 ++ } ++ }, ++ useTabs: { ++ since: "1.0.0", ++ category: CATEGORY_GLOBAL, ++ type: "boolean", ++ default: false, ++ description: "Indent with tabs instead of spaces." ++ } ++}; ++var coreOptions = { ++ CATEGORY_CONFIG, ++ CATEGORY_EDITOR, ++ CATEGORY_FORMAT, ++ CATEGORY_OTHER, ++ CATEGORY_OUTPUT, ++ CATEGORY_GLOBAL, ++ CATEGORY_SPECIAL, ++ options ++}; ++ ++var require$$1 = getCjsExportFromNamespace(_package$1); ++ ++const semver$1 = { ++ compare: compare_1, ++ lt: lt_1, ++ gte: gte_1 ++}; ++const currentVersion = require$$1.version; ++const coreOptions$1 = coreOptions.options; ++/** ++ * Strings in `plugins` and `pluginSearchDirs` are handled by a wrapped version ++ * of this function created by `withPlugins`. Don't pass them here directly. ++ * @param {object} param0 ++ * @param {(string | object)[]=} param0.plugins Strings are resolved by `withPlugins`. ++ * @param {string[]=} param0.pluginSearchDirs Added by `withPlugins`. ++ * @param {boolean=} param0.showUnreleased ++ * @param {boolean=} param0.showDeprecated ++ * @param {boolean=} param0.showInternal ++ */ ++ ++function getSupportInfo({ ++ plugins = [], ++ showUnreleased = false, ++ showDeprecated = false, ++ showInternal = false ++} = {}) { ++ // pre-release version is smaller than the normal version in semver, ++ // we need to treat it as the normal one so as to test new features. ++ const version = currentVersion.split("-", 1)[0]; ++ const options = arrayify(Object.assign({}, ...plugins.map(({ ++ options ++ }) => options), coreOptions$1), "name").filter(option => filterSince(option) && filterDeprecated(option)).sort((a, b) => a.name === b.name ? 0 : a.name < b.name ? -1 : 1).map(mapInternal).map(option => { ++ option = Object.assign({}, option); ++ ++ if (Array.isArray(option.default)) { ++ option.default = option.default.length === 1 ? option.default[0].value : option.default.filter(filterSince).sort((info1, info2) => semver$1.compare(info2.since, info1.since))[0].value; ++ } ++ ++ if (Array.isArray(option.choices)) { ++ option.choices = option.choices.filter(option => filterSince(option) && filterDeprecated(option)); ++ } ++ ++ const filteredPlugins = plugins.filter(plugin => plugin.defaultOptions && plugin.defaultOptions[option.name] !== undefined); ++ const pluginDefaults = filteredPlugins.reduce((reduced, plugin) => { ++ reduced[plugin.name] = plugin.defaultOptions[option.name]; ++ return reduced; ++ }, {}); ++ return Object.assign({}, option, { ++ pluginDefaults ++ }); ++ }); ++ const languages = plugins.reduce((all, plugin) => all.concat(plugin.languages || []), []).filter(filterSince); ++ return { ++ languages, ++ options ++ }; ++ ++ function filterSince(object) { ++ return showUnreleased || !("since" in object) || object.since && semver$1.gte(version, object.since); ++ } ++ ++ function filterDeprecated(object) { ++ return showDeprecated || !("deprecated" in object) || object.deprecated && semver$1.lt(version, object.deprecated); ++ } ++ ++ function mapInternal(object) { ++ if (showInternal) { ++ return object; ++ } ++ ++ const newObject = _objectWithoutPropertiesLoose(object, ["cliName", "cliCategory", "cliDescription"]); ++ ++ return newObject; ++ } ++} ++ ++var support = { ++ getSupportInfo ++}; ++ ++/*! ***************************************************************************** ++Copyright (c) Microsoft Corporation. All rights reserved. ++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 ++ ++THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY ++KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED ++WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, ++MERCHANTABLITY OR NON-INFRINGEMENT. ++ ++See the Apache Version 2.0 License for specific language governing permissions ++and limitations under the License. ++***************************************************************************** */ ++ ++/* global Reflect, Promise */ ++var extendStatics = function (d, b) { ++ extendStatics = Object.setPrototypeOf || { ++ __proto__: [] ++ } instanceof Array && function (d, b) { ++ d.__proto__ = b; ++ } || function (d, b) { ++ for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; ++ }; ++ ++ return extendStatics(d, b); ++}; ++ ++function __extends(d, b) { ++ extendStatics(d, b); ++ ++ function __() { ++ this.constructor = d; ++ } ++ ++ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); ++} ++var __assign = function () { ++ __assign = Object.assign || function __assign(t) { ++ for (var s, i = 1, n = arguments.length; i < n; i++) { ++ s = arguments[i]; ++ ++ for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p]; ++ } ++ ++ return t; ++ }; ++ ++ return __assign.apply(this, arguments); ++}; ++function __rest(s, e) { ++ var t = {}; ++ ++ for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p]; ++ ++ if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { ++ if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]]; ++ } ++ return t; ++} ++function __decorate(decorators, target, key, desc) { ++ var c = arguments.length, ++ r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, ++ d; ++ if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; ++ return c > 3 && r && Object.defineProperty(target, key, r), r; ++} ++function __param(paramIndex, decorator) { ++ return function (target, key) { ++ decorator(target, key, paramIndex); ++ }; ++} ++function __metadata(metadataKey, metadataValue) { ++ if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue); ++} ++function __awaiter(thisArg, _arguments, P, generator) { ++ return new (P || (P = Promise))(function (resolve, reject) { ++ function fulfilled(value) { ++ try { ++ step(generator.next(value)); ++ } catch (e) { ++ reject(e); ++ } ++ } ++ ++ function rejected(value) { ++ try { ++ step(generator["throw"](value)); ++ } catch (e) { ++ reject(e); ++ } ++ } ++ ++ function step(result) { ++ result.done ? resolve(result.value) : new P(function (resolve) { ++ resolve(result.value); ++ }).then(fulfilled, rejected); ++ } ++ ++ step((generator = generator.apply(thisArg, _arguments || [])).next()); ++ }); ++} ++function __generator(thisArg, body) { ++ var _ = { ++ label: 0, ++ sent: function () { ++ if (t[0] & 1) throw t[1]; ++ return t[1]; ++ }, ++ trys: [], ++ ops: [] ++ }, ++ f, ++ y, ++ t, ++ g; ++ return g = { ++ next: verb(0), ++ "throw": verb(1), ++ "return": verb(2) ++ }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { ++ return this; ++ }), g; ++ ++ function verb(n) { ++ return function (v) { ++ return step([n, v]); ++ }; ++ } ++ ++ function step(op) { ++ if (f) throw new TypeError("Generator is already executing."); ++ ++ while (_) try { ++ if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; ++ if (y = 0, t) op = [op[0] & 2, t.value]; ++ ++ switch (op[0]) { ++ case 0: ++ case 1: ++ t = op; ++ break; ++ ++ case 4: ++ _.label++; ++ return { ++ value: op[1], ++ done: false ++ }; ++ ++ case 5: ++ _.label++; ++ y = op[1]; ++ op = [0]; ++ continue; ++ ++ case 7: ++ op = _.ops.pop(); ++ ++ _.trys.pop(); ++ ++ continue; ++ ++ default: ++ if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { ++ _ = 0; ++ continue; ++ } ++ ++ if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) { ++ _.label = op[1]; ++ break; ++ } ++ ++ if (op[0] === 6 && _.label < t[1]) { ++ _.label = t[1]; ++ t = op; ++ break; ++ } ++ ++ if (t && _.label < t[2]) { ++ _.label = t[2]; ++ ++ _.ops.push(op); ++ ++ break; ++ } ++ ++ if (t[2]) _.ops.pop(); ++ ++ _.trys.pop(); ++ ++ continue; ++ } ++ ++ op = body.call(thisArg, _); ++ } catch (e) { ++ op = [6, e]; ++ y = 0; ++ } finally { ++ f = t = 0; ++ } ++ ++ if (op[0] & 5) throw op[1]; ++ return { ++ value: op[0] ? op[1] : void 0, ++ done: true ++ }; ++ } ++} ++function __exportStar(m, exports) { ++ for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; ++} ++function __values(o) { ++ var m = typeof Symbol === "function" && o[Symbol.iterator], ++ i = 0; ++ if (m) return m.call(o); ++ return { ++ next: function () { ++ if (o && i >= o.length) o = void 0; ++ return { ++ value: o && o[i++], ++ done: !o ++ }; ++ } ++ }; ++} ++function __read(o, n) { ++ var m = typeof Symbol === "function" && o[Symbol.iterator]; ++ if (!m) return o; ++ var i = m.call(o), ++ r, ++ ar = [], ++ e; ++ ++ try { ++ while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); ++ } catch (error) { ++ e = { ++ error: error ++ }; ++ } finally { ++ try { ++ if (r && !r.done && (m = i["return"])) m.call(i); ++ } finally { ++ if (e) throw e.error; ++ } ++ } ++ ++ return ar; ++} ++function __spread() { ++ for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i])); ++ ++ return ar; ++} ++function __spreadArrays() { ++ for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; ++ ++ for (var r = Array(s), k = 0, i = 0; i < il; i++) for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) r[k] = a[j]; ++ ++ return r; ++} ++function __await(v) { ++ return this instanceof __await ? (this.v = v, this) : new __await(v); ++} ++function __asyncGenerator(thisArg, _arguments, generator) { ++ if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); ++ var g = generator.apply(thisArg, _arguments || []), ++ i, ++ q = []; ++ return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { ++ return this; ++ }, i; ++ ++ function verb(n) { ++ if (g[n]) i[n] = function (v) { ++ return new Promise(function (a, b) { ++ q.push([n, v, a, b]) > 1 || resume(n, v); ++ }); ++ }; ++ } ++ ++ function resume(n, v) { ++ try { ++ step(g[n](v)); ++ } catch (e) { ++ settle(q[0][3], e); ++ } ++ } ++ ++ function step(r) { ++ r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); ++ } ++ ++ function fulfill(value) { ++ resume("next", value); ++ } ++ ++ function reject(value) { ++ resume("throw", value); ++ } ++ ++ function settle(f, v) { ++ if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); ++ } ++} ++function __asyncDelegator(o) { ++ var i, p; ++ return i = {}, verb("next"), verb("throw", function (e) { ++ throw e; ++ }), verb("return"), i[Symbol.iterator] = function () { ++ return this; ++ }, i; ++ ++ function verb(n, f) { ++ i[n] = o[n] ? function (v) { ++ return (p = !p) ? { ++ value: __await(o[n](v)), ++ done: n === "return" ++ } : f ? f(v) : v; ++ } : f; ++ } ++} ++function __asyncValues(o) { ++ if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); ++ var m = o[Symbol.asyncIterator], ++ i; ++ return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { ++ return this; ++ }, i); ++ ++ function verb(n) { ++ i[n] = o[n] && function (v) { ++ return new Promise(function (resolve, reject) { ++ v = o[n](v), settle(resolve, reject, v.done, v.value); ++ }); ++ }; ++ } ++ ++ function settle(resolve, reject, d, v) { ++ Promise.resolve(v).then(function (v) { ++ resolve({ ++ value: v, ++ done: d ++ }); ++ }, reject); ++ } ++} ++function __makeTemplateObject(cooked, raw) { ++ if (Object.defineProperty) { ++ Object.defineProperty(cooked, "raw", { ++ value: raw ++ }); ++ } else { ++ cooked.raw = raw; ++ } ++ ++ return cooked; ++} ++function __importStar(mod) { ++ if (mod && mod.__esModule) return mod; ++ var result = {}; ++ if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; ++ result.default = mod; ++ return result; ++} ++function __importDefault(mod) { ++ return mod && mod.__esModule ? mod : { ++ default: mod ++ }; ++} ++ ++var tslib_es6 = /*#__PURE__*/Object.freeze({ ++ __proto__: null, ++ __extends: __extends, ++ get __assign () { return __assign; }, ++ __rest: __rest, ++ __decorate: __decorate, ++ __param: __param, ++ __metadata: __metadata, ++ __awaiter: __awaiter, ++ __generator: __generator, ++ __exportStar: __exportStar, ++ __values: __values, ++ __read: __read, ++ __spread: __spread, ++ __spreadArrays: __spreadArrays, ++ __await: __await, ++ __asyncGenerator: __asyncGenerator, ++ __asyncDelegator: __asyncDelegator, ++ __asyncValues: __asyncValues, ++ __makeTemplateObject: __makeTemplateObject, ++ __importStar: __importStar, ++ __importDefault: __importDefault ++}); ++ ++var api = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ exports.apiDescriptor = { ++ key: key => /^[$_a-zA-Z][$_a-zA-Z0-9]*$/.test(key) ? key : JSON.stringify(key), ++ ++ value(value) { ++ if (value === null || typeof value !== 'object') { ++ return JSON.stringify(value); ++ } ++ ++ if (Array.isArray(value)) { ++ return `[${value.map(subValue => exports.apiDescriptor.value(subValue)).join(', ')}]`; ++ } ++ ++ const keys = Object.keys(value); ++ return keys.length === 0 ? '{}' : `{ ${keys.map(key => `${exports.apiDescriptor.key(key)}: ${exports.apiDescriptor.value(value[key])}`).join(', ')} }`; ++ }, ++ ++ pair: ({ ++ key, ++ value ++ }) => exports.apiDescriptor.value({ ++ [key]: value ++ }) ++ }; ++}); ++unwrapExports(api); ++var api_1 = api.apiDescriptor; ++ ++var tslib_1 = getCjsExportFromNamespace(tslib_es6); ++ ++var descriptors = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ tslib_1.__exportStar(api, exports); ++}); ++unwrapExports(descriptors); ++ ++var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g; ++ ++var escapeStringRegexp = function (str) { ++ if (typeof str !== 'string') { ++ throw new TypeError('Expected a string'); ++ } ++ ++ return str.replace(matchOperatorsRe, '\\$&'); ++}; ++ ++var colorName = { ++ "aliceblue": [240, 248, 255], ++ "antiquewhite": [250, 235, 215], ++ "aqua": [0, 255, 255], ++ "aquamarine": [127, 255, 212], ++ "azure": [240, 255, 255], ++ "beige": [245, 245, 220], ++ "bisque": [255, 228, 196], ++ "black": [0, 0, 0], ++ "blanchedalmond": [255, 235, 205], ++ "blue": [0, 0, 255], ++ "blueviolet": [138, 43, 226], ++ "brown": [165, 42, 42], ++ "burlywood": [222, 184, 135], ++ "cadetblue": [95, 158, 160], ++ "chartreuse": [127, 255, 0], ++ "chocolate": [210, 105, 30], ++ "coral": [255, 127, 80], ++ "cornflowerblue": [100, 149, 237], ++ "cornsilk": [255, 248, 220], ++ "crimson": [220, 20, 60], ++ "cyan": [0, 255, 255], ++ "darkblue": [0, 0, 139], ++ "darkcyan": [0, 139, 139], ++ "darkgoldenrod": [184, 134, 11], ++ "darkgray": [169, 169, 169], ++ "darkgreen": [0, 100, 0], ++ "darkgrey": [169, 169, 169], ++ "darkkhaki": [189, 183, 107], ++ "darkmagenta": [139, 0, 139], ++ "darkolivegreen": [85, 107, 47], ++ "darkorange": [255, 140, 0], ++ "darkorchid": [153, 50, 204], ++ "darkred": [139, 0, 0], ++ "darksalmon": [233, 150, 122], ++ "darkseagreen": [143, 188, 143], ++ "darkslateblue": [72, 61, 139], ++ "darkslategray": [47, 79, 79], ++ "darkslategrey": [47, 79, 79], ++ "darkturquoise": [0, 206, 209], ++ "darkviolet": [148, 0, 211], ++ "deeppink": [255, 20, 147], ++ "deepskyblue": [0, 191, 255], ++ "dimgray": [105, 105, 105], ++ "dimgrey": [105, 105, 105], ++ "dodgerblue": [30, 144, 255], ++ "firebrick": [178, 34, 34], ++ "floralwhite": [255, 250, 240], ++ "forestgreen": [34, 139, 34], ++ "fuchsia": [255, 0, 255], ++ "gainsboro": [220, 220, 220], ++ "ghostwhite": [248, 248, 255], ++ "gold": [255, 215, 0], ++ "goldenrod": [218, 165, 32], ++ "gray": [128, 128, 128], ++ "green": [0, 128, 0], ++ "greenyellow": [173, 255, 47], ++ "grey": [128, 128, 128], ++ "honeydew": [240, 255, 240], ++ "hotpink": [255, 105, 180], ++ "indianred": [205, 92, 92], ++ "indigo": [75, 0, 130], ++ "ivory": [255, 255, 240], ++ "khaki": [240, 230, 140], ++ "lavender": [230, 230, 250], ++ "lavenderblush": [255, 240, 245], ++ "lawngreen": [124, 252, 0], ++ "lemonchiffon": [255, 250, 205], ++ "lightblue": [173, 216, 230], ++ "lightcoral": [240, 128, 128], ++ "lightcyan": [224, 255, 255], ++ "lightgoldenrodyellow": [250, 250, 210], ++ "lightgray": [211, 211, 211], ++ "lightgreen": [144, 238, 144], ++ "lightgrey": [211, 211, 211], ++ "lightpink": [255, 182, 193], ++ "lightsalmon": [255, 160, 122], ++ "lightseagreen": [32, 178, 170], ++ "lightskyblue": [135, 206, 250], ++ "lightslategray": [119, 136, 153], ++ "lightslategrey": [119, 136, 153], ++ "lightsteelblue": [176, 196, 222], ++ "lightyellow": [255, 255, 224], ++ "lime": [0, 255, 0], ++ "limegreen": [50, 205, 50], ++ "linen": [250, 240, 230], ++ "magenta": [255, 0, 255], ++ "maroon": [128, 0, 0], ++ "mediumaquamarine": [102, 205, 170], ++ "mediumblue": [0, 0, 205], ++ "mediumorchid": [186, 85, 211], ++ "mediumpurple": [147, 112, 219], ++ "mediumseagreen": [60, 179, 113], ++ "mediumslateblue": [123, 104, 238], ++ "mediumspringgreen": [0, 250, 154], ++ "mediumturquoise": [72, 209, 204], ++ "mediumvioletred": [199, 21, 133], ++ "midnightblue": [25, 25, 112], ++ "mintcream": [245, 255, 250], ++ "mistyrose": [255, 228, 225], ++ "moccasin": [255, 228, 181], ++ "navajowhite": [255, 222, 173], ++ "navy": [0, 0, 128], ++ "oldlace": [253, 245, 230], ++ "olive": [128, 128, 0], ++ "olivedrab": [107, 142, 35], ++ "orange": [255, 165, 0], ++ "orangered": [255, 69, 0], ++ "orchid": [218, 112, 214], ++ "palegoldenrod": [238, 232, 170], ++ "palegreen": [152, 251, 152], ++ "paleturquoise": [175, 238, 238], ++ "palevioletred": [219, 112, 147], ++ "papayawhip": [255, 239, 213], ++ "peachpuff": [255, 218, 185], ++ "peru": [205, 133, 63], ++ "pink": [255, 192, 203], ++ "plum": [221, 160, 221], ++ "powderblue": [176, 224, 230], ++ "purple": [128, 0, 128], ++ "rebeccapurple": [102, 51, 153], ++ "red": [255, 0, 0], ++ "rosybrown": [188, 143, 143], ++ "royalblue": [65, 105, 225], ++ "saddlebrown": [139, 69, 19], ++ "salmon": [250, 128, 114], ++ "sandybrown": [244, 164, 96], ++ "seagreen": [46, 139, 87], ++ "seashell": [255, 245, 238], ++ "sienna": [160, 82, 45], ++ "silver": [192, 192, 192], ++ "skyblue": [135, 206, 235], ++ "slateblue": [106, 90, 205], ++ "slategray": [112, 128, 144], ++ "slategrey": [112, 128, 144], ++ "snow": [255, 250, 250], ++ "springgreen": [0, 255, 127], ++ "steelblue": [70, 130, 180], ++ "tan": [210, 180, 140], ++ "teal": [0, 128, 128], ++ "thistle": [216, 191, 216], ++ "tomato": [255, 99, 71], ++ "turquoise": [64, 224, 208], ++ "violet": [238, 130, 238], ++ "wheat": [245, 222, 179], ++ "white": [255, 255, 255], ++ "whitesmoke": [245, 245, 245], ++ "yellow": [255, 255, 0], ++ "yellowgreen": [154, 205, 50] ++}; ++ ++var conversions = createCommonjsModule(function (module) { ++ /* MIT license */ ++ // NOTE: conversions should only return primitive values (i.e. arrays, or ++ // values that give correct `typeof` results). ++ // do not use box values types (i.e. Number(), String(), etc.) ++ var reverseKeywords = {}; ++ ++ for (var key in colorName) { ++ if (colorName.hasOwnProperty(key)) { ++ reverseKeywords[colorName[key]] = key; ++ } ++ } ++ ++ var convert = module.exports = { ++ rgb: { ++ channels: 3, ++ labels: 'rgb' ++ }, ++ hsl: { ++ channels: 3, ++ labels: 'hsl' ++ }, ++ hsv: { ++ channels: 3, ++ labels: 'hsv' ++ }, ++ hwb: { ++ channels: 3, ++ labels: 'hwb' ++ }, ++ cmyk: { ++ channels: 4, ++ labels: 'cmyk' ++ }, ++ xyz: { ++ channels: 3, ++ labels: 'xyz' ++ }, ++ lab: { ++ channels: 3, ++ labels: 'lab' ++ }, ++ lch: { ++ channels: 3, ++ labels: 'lch' ++ }, ++ hex: { ++ channels: 1, ++ labels: ['hex'] ++ }, ++ keyword: { ++ channels: 1, ++ labels: ['keyword'] ++ }, ++ ansi16: { ++ channels: 1, ++ labels: ['ansi16'] ++ }, ++ ansi256: { ++ channels: 1, ++ labels: ['ansi256'] ++ }, ++ hcg: { ++ channels: 3, ++ labels: ['h', 'c', 'g'] ++ }, ++ apple: { ++ channels: 3, ++ labels: ['r16', 'g16', 'b16'] ++ }, ++ gray: { ++ channels: 1, ++ labels: ['gray'] ++ } ++ }; // hide .channels and .labels properties ++ ++ for (var model in convert) { ++ if (convert.hasOwnProperty(model)) { ++ if (!('channels' in convert[model])) { ++ throw new Error('missing channels property: ' + model); ++ } ++ ++ if (!('labels' in convert[model])) { ++ throw new Error('missing channel labels property: ' + model); ++ } ++ ++ if (convert[model].labels.length !== convert[model].channels) { ++ throw new Error('channel and label counts mismatch: ' + model); ++ } ++ ++ var channels = convert[model].channels; ++ var labels = convert[model].labels; ++ delete convert[model].channels; ++ delete convert[model].labels; ++ Object.defineProperty(convert[model], 'channels', { ++ value: channels ++ }); ++ Object.defineProperty(convert[model], 'labels', { ++ value: labels ++ }); ++ } ++ } ++ ++ convert.rgb.hsl = function (rgb) { ++ var r = rgb[0] / 255; ++ var g = rgb[1] / 255; ++ var b = rgb[2] / 255; ++ var min = Math.min(r, g, b); ++ var max = Math.max(r, g, b); ++ var delta = max - min; ++ var h; ++ var s; ++ var l; ++ ++ if (max === min) { ++ h = 0; ++ } else if (r === max) { ++ h = (g - b) / delta; ++ } else if (g === max) { ++ h = 2 + (b - r) / delta; ++ } else if (b === max) { ++ h = 4 + (r - g) / delta; ++ } ++ ++ h = Math.min(h * 60, 360); ++ ++ if (h < 0) { ++ h += 360; ++ } ++ ++ l = (min + max) / 2; ++ ++ if (max === min) { ++ s = 0; ++ } else if (l <= 0.5) { ++ s = delta / (max + min); ++ } else { ++ s = delta / (2 - max - min); ++ } ++ ++ return [h, s * 100, l * 100]; ++ }; ++ ++ convert.rgb.hsv = function (rgb) { ++ var rdif; ++ var gdif; ++ var bdif; ++ var h; ++ var s; ++ var r = rgb[0] / 255; ++ var g = rgb[1] / 255; ++ var b = rgb[2] / 255; ++ var v = Math.max(r, g, b); ++ var diff = v - Math.min(r, g, b); ++ ++ var diffc = function (c) { ++ return (v - c) / 6 / diff + 1 / 2; ++ }; ++ ++ if (diff === 0) { ++ h = s = 0; ++ } else { ++ s = diff / v; ++ rdif = diffc(r); ++ gdif = diffc(g); ++ bdif = diffc(b); ++ ++ if (r === v) { ++ h = bdif - gdif; ++ } else if (g === v) { ++ h = 1 / 3 + rdif - bdif; ++ } else if (b === v) { ++ h = 2 / 3 + gdif - rdif; ++ } ++ ++ if (h < 0) { ++ h += 1; ++ } else if (h > 1) { ++ h -= 1; ++ } ++ } ++ ++ return [h * 360, s * 100, v * 100]; ++ }; ++ ++ convert.rgb.hwb = function (rgb) { ++ var r = rgb[0]; ++ var g = rgb[1]; ++ var b = rgb[2]; ++ var h = convert.rgb.hsl(rgb)[0]; ++ var w = 1 / 255 * Math.min(r, Math.min(g, b)); ++ b = 1 - 1 / 255 * Math.max(r, Math.max(g, b)); ++ return [h, w * 100, b * 100]; ++ }; ++ ++ convert.rgb.cmyk = function (rgb) { ++ var r = rgb[0] / 255; ++ var g = rgb[1] / 255; ++ var b = rgb[2] / 255; ++ var c; ++ var m; ++ var y; ++ var k; ++ k = Math.min(1 - r, 1 - g, 1 - b); ++ c = (1 - r - k) / (1 - k) || 0; ++ m = (1 - g - k) / (1 - k) || 0; ++ y = (1 - b - k) / (1 - k) || 0; ++ return [c * 100, m * 100, y * 100, k * 100]; ++ }; ++ /** ++ * See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance ++ * */ ++ ++ ++ function comparativeDistance(x, y) { ++ return Math.pow(x[0] - y[0], 2) + Math.pow(x[1] - y[1], 2) + Math.pow(x[2] - y[2], 2); ++ } ++ ++ convert.rgb.keyword = function (rgb) { ++ var reversed = reverseKeywords[rgb]; ++ ++ if (reversed) { ++ return reversed; ++ } ++ ++ var currentClosestDistance = Infinity; ++ var currentClosestKeyword; ++ ++ for (var keyword in colorName) { ++ if (colorName.hasOwnProperty(keyword)) { ++ var value = colorName[keyword]; // Compute comparative distance ++ ++ var distance = comparativeDistance(rgb, value); // Check if its less, if so set as closest ++ ++ if (distance < currentClosestDistance) { ++ currentClosestDistance = distance; ++ currentClosestKeyword = keyword; ++ } ++ } ++ } ++ ++ return currentClosestKeyword; ++ }; ++ ++ convert.keyword.rgb = function (keyword) { ++ return colorName[keyword]; ++ }; ++ ++ convert.rgb.xyz = function (rgb) { ++ var r = rgb[0] / 255; ++ var g = rgb[1] / 255; ++ var b = rgb[2] / 255; // assume sRGB ++ ++ r = r > 0.04045 ? Math.pow((r + 0.055) / 1.055, 2.4) : r / 12.92; ++ g = g > 0.04045 ? Math.pow((g + 0.055) / 1.055, 2.4) : g / 12.92; ++ b = b > 0.04045 ? Math.pow((b + 0.055) / 1.055, 2.4) : b / 12.92; ++ var x = r * 0.4124 + g * 0.3576 + b * 0.1805; ++ var y = r * 0.2126 + g * 0.7152 + b * 0.0722; ++ var z = r * 0.0193 + g * 0.1192 + b * 0.9505; ++ return [x * 100, y * 100, z * 100]; ++ }; ++ ++ convert.rgb.lab = function (rgb) { ++ var xyz = convert.rgb.xyz(rgb); ++ var x = xyz[0]; ++ var y = xyz[1]; ++ var z = xyz[2]; ++ var l; ++ var a; ++ var b; ++ x /= 95.047; ++ y /= 100; ++ z /= 108.883; ++ x = x > 0.008856 ? Math.pow(x, 1 / 3) : 7.787 * x + 16 / 116; ++ y = y > 0.008856 ? Math.pow(y, 1 / 3) : 7.787 * y + 16 / 116; ++ z = z > 0.008856 ? Math.pow(z, 1 / 3) : 7.787 * z + 16 / 116; ++ l = 116 * y - 16; ++ a = 500 * (x - y); ++ b = 200 * (y - z); ++ return [l, a, b]; ++ }; ++ ++ convert.hsl.rgb = function (hsl) { ++ var h = hsl[0] / 360; ++ var s = hsl[1] / 100; ++ var l = hsl[2] / 100; ++ var t1; ++ var t2; ++ var t3; ++ var rgb; ++ var val; ++ ++ if (s === 0) { ++ val = l * 255; ++ return [val, val, val]; ++ } ++ ++ if (l < 0.5) { ++ t2 = l * (1 + s); ++ } else { ++ t2 = l + s - l * s; ++ } ++ ++ t1 = 2 * l - t2; ++ rgb = [0, 0, 0]; ++ ++ for (var i = 0; i < 3; i++) { ++ t3 = h + 1 / 3 * -(i - 1); ++ ++ if (t3 < 0) { ++ t3++; ++ } ++ ++ if (t3 > 1) { ++ t3--; ++ } ++ ++ if (6 * t3 < 1) { ++ val = t1 + (t2 - t1) * 6 * t3; ++ } else if (2 * t3 < 1) { ++ val = t2; ++ } else if (3 * t3 < 2) { ++ val = t1 + (t2 - t1) * (2 / 3 - t3) * 6; ++ } else { ++ val = t1; ++ } ++ ++ rgb[i] = val * 255; ++ } ++ ++ return rgb; ++ }; ++ ++ convert.hsl.hsv = function (hsl) { ++ var h = hsl[0]; ++ var s = hsl[1] / 100; ++ var l = hsl[2] / 100; ++ var smin = s; ++ var lmin = Math.max(l, 0.01); ++ var sv; ++ var v; ++ l *= 2; ++ s *= l <= 1 ? l : 2 - l; ++ smin *= lmin <= 1 ? lmin : 2 - lmin; ++ v = (l + s) / 2; ++ sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l + s); ++ return [h, sv * 100, v * 100]; ++ }; ++ ++ convert.hsv.rgb = function (hsv) { ++ var h = hsv[0] / 60; ++ var s = hsv[1] / 100; ++ var v = hsv[2] / 100; ++ var hi = Math.floor(h) % 6; ++ var f = h - Math.floor(h); ++ var p = 255 * v * (1 - s); ++ var q = 255 * v * (1 - s * f); ++ var t = 255 * v * (1 - s * (1 - f)); ++ v *= 255; ++ ++ switch (hi) { ++ case 0: ++ return [v, t, p]; ++ ++ case 1: ++ return [q, v, p]; ++ ++ case 2: ++ return [p, v, t]; ++ ++ case 3: ++ return [p, q, v]; ++ ++ case 4: ++ return [t, p, v]; ++ ++ case 5: ++ return [v, p, q]; ++ } ++ }; ++ ++ convert.hsv.hsl = function (hsv) { ++ var h = hsv[0]; ++ var s = hsv[1] / 100; ++ var v = hsv[2] / 100; ++ var vmin = Math.max(v, 0.01); ++ var lmin; ++ var sl; ++ var l; ++ l = (2 - s) * v; ++ lmin = (2 - s) * vmin; ++ sl = s * vmin; ++ sl /= lmin <= 1 ? lmin : 2 - lmin; ++ sl = sl || 0; ++ l /= 2; ++ return [h, sl * 100, l * 100]; ++ }; // http://dev.w3.org/csswg/css-color/#hwb-to-rgb ++ ++ ++ convert.hwb.rgb = function (hwb) { ++ var h = hwb[0] / 360; ++ var wh = hwb[1] / 100; ++ var bl = hwb[2] / 100; ++ var ratio = wh + bl; ++ var i; ++ var v; ++ var f; ++ var n; // wh + bl cant be > 1 ++ ++ if (ratio > 1) { ++ wh /= ratio; ++ bl /= ratio; ++ } ++ ++ i = Math.floor(6 * h); ++ v = 1 - bl; ++ f = 6 * h - i; ++ ++ if ((i & 0x01) !== 0) { ++ f = 1 - f; ++ } ++ ++ n = wh + f * (v - wh); // linear interpolation ++ ++ var r; ++ var g; ++ var b; ++ ++ switch (i) { ++ default: ++ case 6: ++ case 0: ++ r = v; ++ g = n; ++ b = wh; ++ break; ++ ++ case 1: ++ r = n; ++ g = v; ++ b = wh; ++ break; ++ ++ case 2: ++ r = wh; ++ g = v; ++ b = n; ++ break; ++ ++ case 3: ++ r = wh; ++ g = n; ++ b = v; ++ break; ++ ++ case 4: ++ r = n; ++ g = wh; ++ b = v; ++ break; ++ ++ case 5: ++ r = v; ++ g = wh; ++ b = n; ++ break; ++ } ++ ++ return [r * 255, g * 255, b * 255]; ++ }; ++ ++ convert.cmyk.rgb = function (cmyk) { ++ var c = cmyk[0] / 100; ++ var m = cmyk[1] / 100; ++ var y = cmyk[2] / 100; ++ var k = cmyk[3] / 100; ++ var r; ++ var g; ++ var b; ++ r = 1 - Math.min(1, c * (1 - k) + k); ++ g = 1 - Math.min(1, m * (1 - k) + k); ++ b = 1 - Math.min(1, y * (1 - k) + k); ++ return [r * 255, g * 255, b * 255]; ++ }; ++ ++ convert.xyz.rgb = function (xyz) { ++ var x = xyz[0] / 100; ++ var y = xyz[1] / 100; ++ var z = xyz[2] / 100; ++ var r; ++ var g; ++ var b; ++ r = x * 3.2406 + y * -1.5372 + z * -0.4986; ++ g = x * -0.9689 + y * 1.8758 + z * 0.0415; ++ b = x * 0.0557 + y * -0.2040 + z * 1.0570; // assume sRGB ++ ++ r = r > 0.0031308 ? 1.055 * Math.pow(r, 1.0 / 2.4) - 0.055 : r * 12.92; ++ g = g > 0.0031308 ? 1.055 * Math.pow(g, 1.0 / 2.4) - 0.055 : g * 12.92; ++ b = b > 0.0031308 ? 1.055 * Math.pow(b, 1.0 / 2.4) - 0.055 : b * 12.92; ++ r = Math.min(Math.max(0, r), 1); ++ g = Math.min(Math.max(0, g), 1); ++ b = Math.min(Math.max(0, b), 1); ++ return [r * 255, g * 255, b * 255]; ++ }; ++ ++ convert.xyz.lab = function (xyz) { ++ var x = xyz[0]; ++ var y = xyz[1]; ++ var z = xyz[2]; ++ var l; ++ var a; ++ var b; ++ x /= 95.047; ++ y /= 100; ++ z /= 108.883; ++ x = x > 0.008856 ? Math.pow(x, 1 / 3) : 7.787 * x + 16 / 116; ++ y = y > 0.008856 ? Math.pow(y, 1 / 3) : 7.787 * y + 16 / 116; ++ z = z > 0.008856 ? Math.pow(z, 1 / 3) : 7.787 * z + 16 / 116; ++ l = 116 * y - 16; ++ a = 500 * (x - y); ++ b = 200 * (y - z); ++ return [l, a, b]; ++ }; ++ ++ convert.lab.xyz = function (lab) { ++ var l = lab[0]; ++ var a = lab[1]; ++ var b = lab[2]; ++ var x; ++ var y; ++ var z; ++ y = (l + 16) / 116; ++ x = a / 500 + y; ++ z = y - b / 200; ++ var y2 = Math.pow(y, 3); ++ var x2 = Math.pow(x, 3); ++ var z2 = Math.pow(z, 3); ++ y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787; ++ x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787; ++ z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787; ++ x *= 95.047; ++ y *= 100; ++ z *= 108.883; ++ return [x, y, z]; ++ }; ++ ++ convert.lab.lch = function (lab) { ++ var l = lab[0]; ++ var a = lab[1]; ++ var b = lab[2]; ++ var hr; ++ var h; ++ var c; ++ hr = Math.atan2(b, a); ++ h = hr * 360 / 2 / Math.PI; ++ ++ if (h < 0) { ++ h += 360; ++ } ++ ++ c = Math.sqrt(a * a + b * b); ++ return [l, c, h]; ++ }; ++ ++ convert.lch.lab = function (lch) { ++ var l = lch[0]; ++ var c = lch[1]; ++ var h = lch[2]; ++ var a; ++ var b; ++ var hr; ++ hr = h / 360 * 2 * Math.PI; ++ a = c * Math.cos(hr); ++ b = c * Math.sin(hr); ++ return [l, a, b]; ++ }; ++ ++ convert.rgb.ansi16 = function (args) { ++ var r = args[0]; ++ var g = args[1]; ++ var b = args[2]; ++ var value = 1 in arguments ? arguments[1] : convert.rgb.hsv(args)[2]; // hsv -> ansi16 optimization ++ ++ value = Math.round(value / 50); ++ ++ if (value === 0) { ++ return 30; ++ } ++ ++ var ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255)); ++ ++ if (value === 2) { ++ ansi += 60; ++ } ++ ++ return ansi; ++ }; ++ ++ convert.hsv.ansi16 = function (args) { ++ // optimization here; we already know the value and don't need to get ++ // it converted for us. ++ return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]); ++ }; ++ ++ convert.rgb.ansi256 = function (args) { ++ var r = args[0]; ++ var g = args[1]; ++ var b = args[2]; // we use the extended greyscale palette here, with the exception of ++ // black and white. normal palette only has 4 greyscale shades. ++ ++ if (r === g && g === b) { ++ if (r < 8) { ++ return 16; ++ } ++ ++ if (r > 248) { ++ return 231; ++ } ++ ++ return Math.round((r - 8) / 247 * 24) + 232; ++ } ++ ++ var ansi = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5); ++ return ansi; ++ }; ++ ++ convert.ansi16.rgb = function (args) { ++ var color = args % 10; // handle greyscale ++ ++ if (color === 0 || color === 7) { ++ if (args > 50) { ++ color += 3.5; ++ } ++ ++ color = color / 10.5 * 255; ++ return [color, color, color]; ++ } ++ ++ var mult = (~~(args > 50) + 1) * 0.5; ++ var r = (color & 1) * mult * 255; ++ var g = (color >> 1 & 1) * mult * 255; ++ var b = (color >> 2 & 1) * mult * 255; ++ return [r, g, b]; ++ }; ++ ++ convert.ansi256.rgb = function (args) { ++ // handle greyscale ++ if (args >= 232) { ++ var c = (args - 232) * 10 + 8; ++ return [c, c, c]; ++ } ++ ++ args -= 16; ++ var rem; ++ var r = Math.floor(args / 36) / 5 * 255; ++ var g = Math.floor((rem = args % 36) / 6) / 5 * 255; ++ var b = rem % 6 / 5 * 255; ++ return [r, g, b]; ++ }; ++ ++ convert.rgb.hex = function (args) { ++ var integer = ((Math.round(args[0]) & 0xFF) << 16) + ((Math.round(args[1]) & 0xFF) << 8) + (Math.round(args[2]) & 0xFF); ++ var string = integer.toString(16).toUpperCase(); ++ return '000000'.substring(string.length) + string; ++ }; ++ ++ convert.hex.rgb = function (args) { ++ var match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i); ++ ++ if (!match) { ++ return [0, 0, 0]; ++ } ++ ++ var colorString = match[0]; ++ ++ if (match[0].length === 3) { ++ colorString = colorString.split('').map(function (char) { ++ return char + char; ++ }).join(''); ++ } ++ ++ var integer = parseInt(colorString, 16); ++ var r = integer >> 16 & 0xFF; ++ var g = integer >> 8 & 0xFF; ++ var b = integer & 0xFF; ++ return [r, g, b]; ++ }; ++ ++ convert.rgb.hcg = function (rgb) { ++ var r = rgb[0] / 255; ++ var g = rgb[1] / 255; ++ var b = rgb[2] / 255; ++ var max = Math.max(Math.max(r, g), b); ++ var min = Math.min(Math.min(r, g), b); ++ var chroma = max - min; ++ var grayscale; ++ var hue; ++ ++ if (chroma < 1) { ++ grayscale = min / (1 - chroma); ++ } else { ++ grayscale = 0; ++ } ++ ++ if (chroma <= 0) { ++ hue = 0; ++ } else if (max === r) { ++ hue = (g - b) / chroma % 6; ++ } else if (max === g) { ++ hue = 2 + (b - r) / chroma; ++ } else { ++ hue = 4 + (r - g) / chroma + 4; ++ } ++ ++ hue /= 6; ++ hue %= 1; ++ return [hue * 360, chroma * 100, grayscale * 100]; ++ }; ++ ++ convert.hsl.hcg = function (hsl) { ++ var s = hsl[1] / 100; ++ var l = hsl[2] / 100; ++ var c = 1; ++ var f = 0; ++ ++ if (l < 0.5) { ++ c = 2.0 * s * l; ++ } else { ++ c = 2.0 * s * (1.0 - l); ++ } ++ ++ if (c < 1.0) { ++ f = (l - 0.5 * c) / (1.0 - c); ++ } ++ ++ return [hsl[0], c * 100, f * 100]; ++ }; ++ ++ convert.hsv.hcg = function (hsv) { ++ var s = hsv[1] / 100; ++ var v = hsv[2] / 100; ++ var c = s * v; ++ var f = 0; ++ ++ if (c < 1.0) { ++ f = (v - c) / (1 - c); ++ } ++ ++ return [hsv[0], c * 100, f * 100]; ++ }; ++ ++ convert.hcg.rgb = function (hcg) { ++ var h = hcg[0] / 360; ++ var c = hcg[1] / 100; ++ var g = hcg[2] / 100; ++ ++ if (c === 0.0) { ++ return [g * 255, g * 255, g * 255]; ++ } ++ ++ var pure = [0, 0, 0]; ++ var hi = h % 1 * 6; ++ var v = hi % 1; ++ var w = 1 - v; ++ var mg = 0; ++ ++ switch (Math.floor(hi)) { ++ case 0: ++ pure[0] = 1; ++ pure[1] = v; ++ pure[2] = 0; ++ break; ++ ++ case 1: ++ pure[0] = w; ++ pure[1] = 1; ++ pure[2] = 0; ++ break; ++ ++ case 2: ++ pure[0] = 0; ++ pure[1] = 1; ++ pure[2] = v; ++ break; ++ ++ case 3: ++ pure[0] = 0; ++ pure[1] = w; ++ pure[2] = 1; ++ break; ++ ++ case 4: ++ pure[0] = v; ++ pure[1] = 0; ++ pure[2] = 1; ++ break; ++ ++ default: ++ pure[0] = 1; ++ pure[1] = 0; ++ pure[2] = w; ++ } ++ ++ mg = (1.0 - c) * g; ++ return [(c * pure[0] + mg) * 255, (c * pure[1] + mg) * 255, (c * pure[2] + mg) * 255]; ++ }; ++ ++ convert.hcg.hsv = function (hcg) { ++ var c = hcg[1] / 100; ++ var g = hcg[2] / 100; ++ var v = c + g * (1.0 - c); ++ var f = 0; ++ ++ if (v > 0.0) { ++ f = c / v; ++ } ++ ++ return [hcg[0], f * 100, v * 100]; ++ }; ++ ++ convert.hcg.hsl = function (hcg) { ++ var c = hcg[1] / 100; ++ var g = hcg[2] / 100; ++ var l = g * (1.0 - c) + 0.5 * c; ++ var s = 0; ++ ++ if (l > 0.0 && l < 0.5) { ++ s = c / (2 * l); ++ } else if (l >= 0.5 && l < 1.0) { ++ s = c / (2 * (1 - l)); ++ } ++ ++ return [hcg[0], s * 100, l * 100]; ++ }; ++ ++ convert.hcg.hwb = function (hcg) { ++ var c = hcg[1] / 100; ++ var g = hcg[2] / 100; ++ var v = c + g * (1.0 - c); ++ return [hcg[0], (v - c) * 100, (1 - v) * 100]; ++ }; ++ ++ convert.hwb.hcg = function (hwb) { ++ var w = hwb[1] / 100; ++ var b = hwb[2] / 100; ++ var v = 1 - b; ++ var c = v - w; ++ var g = 0; ++ ++ if (c < 1) { ++ g = (v - c) / (1 - c); ++ } ++ ++ return [hwb[0], c * 100, g * 100]; ++ }; ++ ++ convert.apple.rgb = function (apple) { ++ return [apple[0] / 65535 * 255, apple[1] / 65535 * 255, apple[2] / 65535 * 255]; ++ }; ++ ++ convert.rgb.apple = function (rgb) { ++ return [rgb[0] / 255 * 65535, rgb[1] / 255 * 65535, rgb[2] / 255 * 65535]; ++ }; ++ ++ convert.gray.rgb = function (args) { ++ return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255]; ++ }; ++ ++ convert.gray.hsl = convert.gray.hsv = function (args) { ++ return [0, 0, args[0]]; ++ }; ++ ++ convert.gray.hwb = function (gray) { ++ return [0, 100, gray[0]]; ++ }; ++ ++ convert.gray.cmyk = function (gray) { ++ return [0, 0, 0, gray[0]]; ++ }; ++ ++ convert.gray.lab = function (gray) { ++ return [gray[0], 0, 0]; ++ }; ++ ++ convert.gray.hex = function (gray) { ++ var val = Math.round(gray[0] / 100 * 255) & 0xFF; ++ var integer = (val << 16) + (val << 8) + val; ++ var string = integer.toString(16).toUpperCase(); ++ return '000000'.substring(string.length) + string; ++ }; ++ ++ convert.rgb.gray = function (rgb) { ++ var val = (rgb[0] + rgb[1] + rgb[2]) / 3; ++ return [val / 255 * 100]; ++ }; ++}); ++var conversions_1 = conversions.rgb; ++var conversions_2 = conversions.hsl; ++var conversions_3 = conversions.hsv; ++var conversions_4 = conversions.hwb; ++var conversions_5 = conversions.cmyk; ++var conversions_6 = conversions.xyz; ++var conversions_7 = conversions.lab; ++var conversions_8 = conversions.lch; ++var conversions_9 = conversions.hex; ++var conversions_10 = conversions.keyword; ++var conversions_11 = conversions.ansi16; ++var conversions_12 = conversions.ansi256; ++var conversions_13 = conversions.hcg; ++var conversions_14 = conversions.apple; ++var conversions_15 = conversions.gray; ++ ++/* ++ this function routes a model to all other models. ++ ++ all functions that are routed have a property `.conversion` attached ++ to the returned synthetic function. This property is an array ++ of strings, each with the steps in between the 'from' and 'to' ++ color models (inclusive). ++ ++ conversions that are not possible simply are not included. ++*/ ++ ++function buildGraph() { ++ var graph = {}; // https://jsperf.com/object-keys-vs-for-in-with-closure/3 ++ ++ var models = Object.keys(conversions); ++ ++ for (var len = models.length, i = 0; i < len; i++) { ++ graph[models[i]] = { ++ // http://jsperf.com/1-vs-infinity ++ // micro-opt, but this is simple. ++ distance: -1, ++ parent: null ++ }; ++ } ++ ++ return graph; ++} // https://en.wikipedia.org/wiki/Breadth-first_search ++ ++ ++function deriveBFS(fromModel) { ++ var graph = buildGraph(); ++ var queue = [fromModel]; // unshift -> queue -> pop ++ ++ graph[fromModel].distance = 0; ++ ++ while (queue.length) { ++ var current = queue.pop(); ++ var adjacents = Object.keys(conversions[current]); ++ ++ for (var len = adjacents.length, i = 0; i < len; i++) { ++ var adjacent = adjacents[i]; ++ var node = graph[adjacent]; ++ ++ if (node.distance === -1) { ++ node.distance = graph[current].distance + 1; ++ node.parent = current; ++ queue.unshift(adjacent); ++ } ++ } ++ } ++ ++ return graph; ++} ++ ++function link(from, to) { ++ return function (args) { ++ return to(from(args)); ++ }; ++} ++ ++function wrapConversion(toModel, graph) { ++ var path = [graph[toModel].parent, toModel]; ++ var fn = conversions[graph[toModel].parent][toModel]; ++ var cur = graph[toModel].parent; ++ ++ while (graph[cur].parent) { ++ path.unshift(graph[cur].parent); ++ fn = link(conversions[graph[cur].parent][cur], fn); ++ cur = graph[cur].parent; ++ } ++ ++ fn.conversion = path; ++ return fn; ++} ++ ++var route = function (fromModel) { ++ var graph = deriveBFS(fromModel); ++ var conversion = {}; ++ var models = Object.keys(graph); ++ ++ for (var len = models.length, i = 0; i < len; i++) { ++ var toModel = models[i]; ++ var node = graph[toModel]; ++ ++ if (node.parent === null) { ++ // no possible conversion, or this node is the source model. ++ continue; ++ } ++ ++ conversion[toModel] = wrapConversion(toModel, graph); ++ } ++ ++ return conversion; ++}; ++ ++var convert = {}; ++var models = Object.keys(conversions); ++ ++function wrapRaw(fn) { ++ var wrappedFn = function (args) { ++ if (args === undefined || args === null) { ++ return args; ++ } ++ ++ if (arguments.length > 1) { ++ args = Array.prototype.slice.call(arguments); ++ } ++ ++ return fn(args); ++ }; // preserve .conversion property if there is one ++ ++ ++ if ('conversion' in fn) { ++ wrappedFn.conversion = fn.conversion; ++ } ++ ++ return wrappedFn; ++} ++ ++function wrapRounded(fn) { ++ var wrappedFn = function (args) { ++ if (args === undefined || args === null) { ++ return args; ++ } ++ ++ if (arguments.length > 1) { ++ args = Array.prototype.slice.call(arguments); ++ } ++ ++ var result = fn(args); // we're assuming the result is an array here. ++ // see notice in conversions.js; don't use box types ++ // in conversion functions. ++ ++ if (typeof result === 'object') { ++ for (var len = result.length, i = 0; i < len; i++) { ++ result[i] = Math.round(result[i]); ++ } ++ } ++ ++ return result; ++ }; // preserve .conversion property if there is one ++ ++ ++ if ('conversion' in fn) { ++ wrappedFn.conversion = fn.conversion; ++ } ++ ++ return wrappedFn; ++} ++ ++models.forEach(function (fromModel) { ++ convert[fromModel] = {}; ++ Object.defineProperty(convert[fromModel], 'channels', { ++ value: conversions[fromModel].channels ++ }); ++ Object.defineProperty(convert[fromModel], 'labels', { ++ value: conversions[fromModel].labels ++ }); ++ var routes = route(fromModel); ++ var routeModels = Object.keys(routes); ++ routeModels.forEach(function (toModel) { ++ var fn = routes[toModel]; ++ convert[fromModel][toModel] = wrapRounded(fn); ++ convert[fromModel][toModel].raw = wrapRaw(fn); ++ }); ++}); ++var colorConvert = convert; ++ ++var ansiStyles = createCommonjsModule(function (module) { ++ ++ const wrapAnsi16 = (fn, offset) => function () { ++ const code = fn.apply(colorConvert, arguments); ++ return `\u001B[${code + offset}m`; ++ }; ++ ++ const wrapAnsi256 = (fn, offset) => function () { ++ const code = fn.apply(colorConvert, arguments); ++ return `\u001B[${38 + offset};5;${code}m`; ++ }; ++ ++ const wrapAnsi16m = (fn, offset) => function () { ++ const rgb = fn.apply(colorConvert, arguments); ++ return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`; ++ }; ++ ++ function assembleStyles() { ++ const codes = new Map(); ++ const styles = { ++ modifier: { ++ reset: [0, 0], ++ // 21 isn't widely supported and 22 does the same thing ++ bold: [1, 22], ++ dim: [2, 22], ++ italic: [3, 23], ++ underline: [4, 24], ++ inverse: [7, 27], ++ hidden: [8, 28], ++ strikethrough: [9, 29] ++ }, ++ color: { ++ black: [30, 39], ++ red: [31, 39], ++ green: [32, 39], ++ yellow: [33, 39], ++ blue: [34, 39], ++ magenta: [35, 39], ++ cyan: [36, 39], ++ white: [37, 39], ++ gray: [90, 39], ++ // Bright color ++ redBright: [91, 39], ++ greenBright: [92, 39], ++ yellowBright: [93, 39], ++ blueBright: [94, 39], ++ magentaBright: [95, 39], ++ cyanBright: [96, 39], ++ whiteBright: [97, 39] ++ }, ++ bgColor: { ++ bgBlack: [40, 49], ++ bgRed: [41, 49], ++ bgGreen: [42, 49], ++ bgYellow: [43, 49], ++ bgBlue: [44, 49], ++ bgMagenta: [45, 49], ++ bgCyan: [46, 49], ++ bgWhite: [47, 49], ++ // Bright color ++ bgBlackBright: [100, 49], ++ bgRedBright: [101, 49], ++ bgGreenBright: [102, 49], ++ bgYellowBright: [103, 49], ++ bgBlueBright: [104, 49], ++ bgMagentaBright: [105, 49], ++ bgCyanBright: [106, 49], ++ bgWhiteBright: [107, 49] ++ } ++ }; // Fix humans ++ ++ styles.color.grey = styles.color.gray; ++ ++ for (const groupName of Object.keys(styles)) { ++ const group = styles[groupName]; ++ ++ for (const styleName of Object.keys(group)) { ++ const style = group[styleName]; ++ styles[styleName] = { ++ open: `\u001B[${style[0]}m`, ++ close: `\u001B[${style[1]}m` ++ }; ++ group[styleName] = styles[styleName]; ++ codes.set(style[0], style[1]); ++ } ++ ++ Object.defineProperty(styles, groupName, { ++ value: group, ++ enumerable: false ++ }); ++ Object.defineProperty(styles, 'codes', { ++ value: codes, ++ enumerable: false ++ }); ++ } ++ ++ const ansi2ansi = n => n; ++ ++ const rgb2rgb = (r, g, b) => [r, g, b]; ++ ++ styles.color.close = '\u001B[39m'; ++ styles.bgColor.close = '\u001B[49m'; ++ styles.color.ansi = { ++ ansi: wrapAnsi16(ansi2ansi, 0) ++ }; ++ styles.color.ansi256 = { ++ ansi256: wrapAnsi256(ansi2ansi, 0) ++ }; ++ styles.color.ansi16m = { ++ rgb: wrapAnsi16m(rgb2rgb, 0) ++ }; ++ styles.bgColor.ansi = { ++ ansi: wrapAnsi16(ansi2ansi, 10) ++ }; ++ styles.bgColor.ansi256 = { ++ ansi256: wrapAnsi256(ansi2ansi, 10) ++ }; ++ styles.bgColor.ansi16m = { ++ rgb: wrapAnsi16m(rgb2rgb, 10) ++ }; ++ ++ for (let key of Object.keys(colorConvert)) { ++ if (typeof colorConvert[key] !== 'object') { ++ continue; ++ } ++ ++ const suite = colorConvert[key]; ++ ++ if (key === 'ansi16') { ++ key = 'ansi'; ++ } ++ ++ if ('ansi16' in suite) { ++ styles.color.ansi[key] = wrapAnsi16(suite.ansi16, 0); ++ styles.bgColor.ansi[key] = wrapAnsi16(suite.ansi16, 10); ++ } ++ ++ if ('ansi256' in suite) { ++ styles.color.ansi256[key] = wrapAnsi256(suite.ansi256, 0); ++ styles.bgColor.ansi256[key] = wrapAnsi256(suite.ansi256, 10); ++ } ++ ++ if ('rgb' in suite) { ++ styles.color.ansi16m[key] = wrapAnsi16m(suite.rgb, 0); ++ styles.bgColor.ansi16m[key] = wrapAnsi16m(suite.rgb, 10); ++ } ++ } ++ ++ return styles; ++ } // Make the export immutable ++ ++ ++ Object.defineProperty(module, 'exports', { ++ enumerable: true, ++ get: assembleStyles ++ }); ++}); ++ ++var hasFlag = (flag, argv) => { ++ argv = argv || process.argv; ++ const prefix = flag.startsWith('-') ? '' : flag.length === 1 ? '-' : '--'; ++ const pos = argv.indexOf(prefix + flag); ++ const terminatorPos = argv.indexOf('--'); ++ return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos); ++}; ++ ++const env = process.env; ++let forceColor; ++ ++if (hasFlag('no-color') || hasFlag('no-colors') || hasFlag('color=false')) { ++ forceColor = false; ++} else if (hasFlag('color') || hasFlag('colors') || hasFlag('color=true') || hasFlag('color=always')) { ++ forceColor = true; ++} ++ ++if ('FORCE_COLOR' in env) { ++ forceColor = env.FORCE_COLOR.length === 0 || parseInt(env.FORCE_COLOR, 10) !== 0; ++} ++ ++function translateLevel(level) { ++ if (level === 0) { ++ return false; ++ } ++ ++ return { ++ level, ++ hasBasic: true, ++ has256: level >= 2, ++ has16m: level >= 3 ++ }; ++} ++ ++function supportsColor(stream) { ++ if (forceColor === false) { ++ return 0; ++ } ++ ++ if (hasFlag('color=16m') || hasFlag('color=full') || hasFlag('color=truecolor')) { ++ return 3; ++ } ++ ++ if (hasFlag('color=256')) { ++ return 2; ++ } ++ ++ if (stream && !stream.isTTY && forceColor !== true) { ++ return 0; ++ } ++ ++ const min = forceColor ? 1 : 0; ++ ++ if (process.platform === 'win32') { ++ // Node.js 7.5.0 is the first version of Node.js to include a patch to ++ // libuv that enables 256 color output on Windows. Anything earlier and it ++ // won't work. However, here we target Node.js 8 at minimum as it is an LTS ++ // release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows ++ // release that supports 256 colors. Windows 10 build 14931 is the first release ++ // that supports 16m/TrueColor. ++ const osRelease = os.release().split('.'); ++ ++ if (Number(process.versions.node.split('.')[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) { ++ return Number(osRelease[2]) >= 14931 ? 3 : 2; ++ } ++ ++ return 1; ++ } ++ ++ if ('CI' in env) { ++ if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env) || env.CI_NAME === 'codeship') { ++ return 1; ++ } ++ ++ return min; ++ } ++ ++ if ('TEAMCITY_VERSION' in env) { ++ return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0; ++ } ++ ++ if (env.COLORTERM === 'truecolor') { ++ return 3; ++ } ++ ++ if ('TERM_PROGRAM' in env) { ++ const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10); ++ ++ switch (env.TERM_PROGRAM) { ++ case 'iTerm.app': ++ return version >= 3 ? 3 : 2; ++ ++ case 'Apple_Terminal': ++ return 2; ++ // No default ++ } ++ } ++ ++ if (/-256(color)?$/i.test(env.TERM)) { ++ return 2; ++ } ++ ++ if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) { ++ return 1; ++ } ++ ++ if ('COLORTERM' in env) { ++ return 1; ++ } ++ ++ if (env.TERM === 'dumb') { ++ return min; ++ } ++ ++ return min; ++} ++ ++function getSupportLevel(stream) { ++ const level = supportsColor(stream); ++ return translateLevel(level); ++} ++ ++var supportsColor_1 = { ++ supportsColor: getSupportLevel, ++ stdout: getSupportLevel(process.stdout), ++ stderr: getSupportLevel(process.stderr) ++}; ++ ++const TEMPLATE_REGEX = /(?:\\(u[a-f\d]{4}|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi; ++const STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g; ++const STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/; ++const ESCAPE_REGEX = /\\(u[a-f\d]{4}|x[a-f\d]{2}|.)|([^\\])/gi; ++const ESCAPES = new Map([['n', '\n'], ['r', '\r'], ['t', '\t'], ['b', '\b'], ['f', '\f'], ['v', '\v'], ['0', '\0'], ['\\', '\\'], ['e', '\u001B'], ['a', '\u0007']]); ++ ++function unescape(c) { ++ if (c[0] === 'u' && c.length === 5 || c[0] === 'x' && c.length === 3) { ++ return String.fromCharCode(parseInt(c.slice(1), 16)); ++ } ++ ++ return ESCAPES.get(c) || c; ++} ++ ++function parseArguments(name, args) { ++ const results = []; ++ const chunks = args.trim().split(/\s*,\s*/g); ++ let matches; ++ ++ for (const chunk of chunks) { ++ if (!isNaN(chunk)) { ++ results.push(Number(chunk)); ++ } else if (matches = chunk.match(STRING_REGEX)) { ++ results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, chr) => escape ? unescape(escape) : chr)); ++ } else { ++ throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`); ++ } ++ } ++ ++ return results; ++} ++ ++function parseStyle(style) { ++ STYLE_REGEX.lastIndex = 0; ++ const results = []; ++ let matches; ++ ++ while ((matches = STYLE_REGEX.exec(style)) !== null) { ++ const name = matches[1]; ++ ++ if (matches[2]) { ++ const args = parseArguments(name, matches[2]); ++ results.push([name].concat(args)); ++ } else { ++ results.push([name]); ++ } ++ } ++ ++ return results; ++} ++ ++function buildStyle(chalk, styles) { ++ const enabled = {}; ++ ++ for (const layer of styles) { ++ for (const style of layer.styles) { ++ enabled[style[0]] = layer.inverse ? null : style.slice(1); ++ } ++ } ++ ++ let current = chalk; ++ ++ for (const styleName of Object.keys(enabled)) { ++ if (Array.isArray(enabled[styleName])) { ++ if (!(styleName in current)) { ++ throw new Error(`Unknown Chalk style: ${styleName}`); ++ } ++ ++ if (enabled[styleName].length > 0) { ++ current = current[styleName].apply(current, enabled[styleName]); ++ } else { ++ current = current[styleName]; ++ } ++ } ++ } ++ ++ return current; ++} ++ ++var templates = (chalk, tmp) => { ++ const styles = []; ++ const chunks = []; ++ let chunk = []; // eslint-disable-next-line max-params ++ ++ tmp.replace(TEMPLATE_REGEX, (m, escapeChar, inverse, style, close, chr) => { ++ if (escapeChar) { ++ chunk.push(unescape(escapeChar)); ++ } else if (style) { ++ const str = chunk.join(''); ++ chunk = []; ++ chunks.push(styles.length === 0 ? str : buildStyle(chalk, styles)(str)); ++ styles.push({ ++ inverse, ++ styles: parseStyle(style) ++ }); ++ } else if (close) { ++ if (styles.length === 0) { ++ throw new Error('Found extraneous } in Chalk template literal'); ++ } ++ ++ chunks.push(buildStyle(chalk, styles)(chunk.join(''))); ++ chunk = []; ++ styles.pop(); ++ } else { ++ chunk.push(chr); ++ } ++ }); ++ chunks.push(chunk.join('')); ++ ++ if (styles.length > 0) { ++ const errMsg = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`; ++ throw new Error(errMsg); ++ } ++ ++ return chunks.join(''); ++}; ++ ++var chalk = createCommonjsModule(function (module) { ++ ++ const stdoutColor = supportsColor_1.stdout; ++ const isSimpleWindowsTerm = process.platform === 'win32' && !(process.env.TERM || '').toLowerCase().startsWith('xterm'); // `supportsColor.level` → `ansiStyles.color[name]` mapping ++ ++ const levelMapping = ['ansi', 'ansi', 'ansi256', 'ansi16m']; // `color-convert` models to exclude from the Chalk API due to conflicts and such ++ ++ const skipModels = new Set(['gray']); ++ const styles = Object.create(null); ++ ++ function applyOptions(obj, options) { ++ options = options || {}; // Detect level if not set manually ++ ++ const scLevel = stdoutColor ? stdoutColor.level : 0; ++ obj.level = options.level === undefined ? scLevel : options.level; ++ obj.enabled = 'enabled' in options ? options.enabled : obj.level > 0; ++ } ++ ++ function Chalk(options) { ++ // We check for this.template here since calling `chalk.constructor()` ++ // by itself will have a `this` of a previously constructed chalk object ++ if (!this || !(this instanceof Chalk) || this.template) { ++ const chalk = {}; ++ applyOptions(chalk, options); ++ ++ chalk.template = function () { ++ const args = [].slice.call(arguments); ++ return chalkTag.apply(null, [chalk.template].concat(args)); ++ }; ++ ++ Object.setPrototypeOf(chalk, Chalk.prototype); ++ Object.setPrototypeOf(chalk.template, chalk); ++ chalk.template.constructor = Chalk; ++ return chalk.template; ++ } ++ ++ applyOptions(this, options); ++ } // Use bright blue on Windows as the normal blue color is illegible ++ ++ ++ if (isSimpleWindowsTerm) { ++ ansiStyles.blue.open = '\u001B[94m'; ++ } ++ ++ for (const key of Object.keys(ansiStyles)) { ++ ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g'); ++ styles[key] = { ++ get() { ++ const codes = ansiStyles[key]; ++ return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, key); ++ } ++ ++ }; ++ } ++ ++ styles.visible = { ++ get() { ++ return build.call(this, this._styles || [], true, 'visible'); ++ } ++ ++ }; ++ ansiStyles.color.closeRe = new RegExp(escapeStringRegexp(ansiStyles.color.close), 'g'); ++ ++ for (const model of Object.keys(ansiStyles.color.ansi)) { ++ if (skipModels.has(model)) { ++ continue; ++ } ++ ++ styles[model] = { ++ get() { ++ const level = this.level; ++ return function () { ++ const open = ansiStyles.color[levelMapping[level]][model].apply(null, arguments); ++ const codes = { ++ open, ++ close: ansiStyles.color.close, ++ closeRe: ansiStyles.color.closeRe ++ }; ++ return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model); ++ }; ++ } ++ ++ }; ++ } ++ ++ ansiStyles.bgColor.closeRe = new RegExp(escapeStringRegexp(ansiStyles.bgColor.close), 'g'); ++ ++ for (const model of Object.keys(ansiStyles.bgColor.ansi)) { ++ if (skipModels.has(model)) { ++ continue; ++ } ++ ++ const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1); ++ styles[bgModel] = { ++ get() { ++ const level = this.level; ++ return function () { ++ const open = ansiStyles.bgColor[levelMapping[level]][model].apply(null, arguments); ++ const codes = { ++ open, ++ close: ansiStyles.bgColor.close, ++ closeRe: ansiStyles.bgColor.closeRe ++ }; ++ return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model); ++ }; ++ } ++ ++ }; ++ } ++ ++ const proto = Object.defineProperties(() => {}, styles); ++ ++ function build(_styles, _empty, key) { ++ const builder = function () { ++ return applyStyle.apply(builder, arguments); ++ }; ++ ++ builder._styles = _styles; ++ builder._empty = _empty; ++ const self = this; ++ Object.defineProperty(builder, 'level', { ++ enumerable: true, ++ ++ get() { ++ return self.level; ++ }, ++ ++ set(level) { ++ self.level = level; ++ } ++ ++ }); ++ Object.defineProperty(builder, 'enabled', { ++ enumerable: true, ++ ++ get() { ++ return self.enabled; ++ }, ++ ++ set(enabled) { ++ self.enabled = enabled; ++ } ++ ++ }); // See below for fix regarding invisible grey/dim combination on Windows ++ ++ builder.hasGrey = this.hasGrey || key === 'gray' || key === 'grey'; // `__proto__` is used because we must return a function, but there is ++ // no way to create a function with a different prototype ++ ++ builder.__proto__ = proto; // eslint-disable-line no-proto ++ ++ return builder; ++ } ++ ++ function applyStyle() { ++ // Support varags, but simply cast to string in case there's only one arg ++ const args = arguments; ++ const argsLen = args.length; ++ let str = String(arguments[0]); ++ ++ if (argsLen === 0) { ++ return ''; ++ } ++ ++ if (argsLen > 1) { ++ // Don't slice `arguments`, it prevents V8 optimizations ++ for (let a = 1; a < argsLen; a++) { ++ str += ' ' + args[a]; ++ } ++ } ++ ++ if (!this.enabled || this.level <= 0 || !str) { ++ return this._empty ? '' : str; ++ } // Turns out that on Windows dimmed gray text becomes invisible in cmd.exe, ++ // see https://github.com/chalk/chalk/issues/58 ++ // If we're on Windows and we're dealing with a gray color, temporarily make 'dim' a noop. ++ ++ ++ const originalDim = ansiStyles.dim.open; ++ ++ if (isSimpleWindowsTerm && this.hasGrey) { ++ ansiStyles.dim.open = ''; ++ } ++ ++ for (const code of this._styles.slice().reverse()) { ++ // Replace any instances already present with a re-opening code ++ // otherwise only the part of the string until said closing code ++ // will be colored, and the rest will simply be 'plain'. ++ str = code.open + str.replace(code.closeRe, code.open) + code.close; // Close the styling before a linebreak and reopen ++ // after next line to fix a bleed issue on macOS ++ // https://github.com/chalk/chalk/pull/92 ++ ++ str = str.replace(/\r?\n/g, `${code.close}$&${code.open}`); ++ } // Reset the original `dim` if we changed it to work around the Windows dimmed gray issue ++ ++ ++ ansiStyles.dim.open = originalDim; ++ return str; ++ } ++ ++ function chalkTag(chalk, strings) { ++ if (!Array.isArray(strings)) { ++ // If chalk() was called by itself or with a string, ++ // return the string itself as a string. ++ return [].slice.call(arguments, 1).join(' '); ++ } ++ ++ const args = [].slice.call(arguments, 2); ++ const parts = [strings.raw[0]]; ++ ++ for (let i = 1; i < strings.length; i++) { ++ parts.push(String(args[i - 1]).replace(/[{}\\]/g, '\\$&')); ++ parts.push(String(strings.raw[i])); ++ } ++ ++ return templates(chalk, parts.join('')); ++ } ++ ++ Object.defineProperties(Chalk.prototype, styles); ++ module.exports = Chalk(); // eslint-disable-line new-cap ++ ++ module.exports.supportsColor = stdoutColor; ++ module.exports.default = module.exports; // For TypeScript ++}); ++var chalk_1 = chalk.supportsColor; ++ ++var common = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ exports.commonDeprecatedHandler = (keyOrPair, redirectTo, { ++ descriptor ++ }) => { ++ const messages = [`${chalk.default.yellow(typeof keyOrPair === 'string' ? descriptor.key(keyOrPair) : descriptor.pair(keyOrPair))} is deprecated`]; ++ ++ if (redirectTo) { ++ messages.push(`we now treat it as ${chalk.default.blue(typeof redirectTo === 'string' ? descriptor.key(redirectTo) : descriptor.pair(redirectTo))}`); ++ } ++ ++ return messages.join('; ') + '.'; ++ }; ++}); ++unwrapExports(common); ++var common_1 = common.commonDeprecatedHandler; ++ ++var deprecated = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ tslib_1.__exportStar(common, exports); ++}); ++unwrapExports(deprecated); ++ ++var common$1 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ exports.commonInvalidHandler = (key, value, utils) => [`Invalid ${chalk.default.red(utils.descriptor.key(key))} value.`, `Expected ${chalk.default.blue(utils.schemas[key].expected(utils))},`, `but received ${chalk.default.red(utils.descriptor.value(value))}.`].join(' '); ++}); ++unwrapExports(common$1); ++var common_1$1 = common$1.commonInvalidHandler; ++ ++var invalid = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ tslib_1.__exportStar(common$1, exports); ++}); ++unwrapExports(invalid); ++ ++/* eslint-disable no-nested-ternary */ ++ ++var arr = []; ++var charCodeCache = []; ++ ++var leven = function (a, b) { ++ if (a === b) { ++ return 0; ++ } ++ ++ var swap = a; // Swapping the strings if `a` is longer than `b` so we know which one is the ++ // shortest & which one is the longest ++ ++ if (a.length > b.length) { ++ a = b; ++ b = swap; ++ } ++ ++ var aLen = a.length; ++ var bLen = b.length; ++ ++ if (aLen === 0) { ++ return bLen; ++ } ++ ++ if (bLen === 0) { ++ return aLen; ++ } // Performing suffix trimming: ++ // We can linearly drop suffix common to both strings since they ++ // don't increase distance at all ++ // Note: `~-` is the bitwise way to perform a `- 1` operation ++ ++ ++ while (aLen > 0 && a.charCodeAt(~-aLen) === b.charCodeAt(~-bLen)) { ++ aLen--; ++ bLen--; ++ } ++ ++ if (aLen === 0) { ++ return bLen; ++ } // Performing prefix trimming ++ // We can linearly drop prefix common to both strings since they ++ // don't increase distance at all ++ ++ ++ var start = 0; ++ ++ while (start < aLen && a.charCodeAt(start) === b.charCodeAt(start)) { ++ start++; ++ } ++ ++ aLen -= start; ++ bLen -= start; ++ ++ if (aLen === 0) { ++ return bLen; ++ } ++ ++ var bCharCode; ++ var ret; ++ var tmp; ++ var tmp2; ++ var i = 0; ++ var j = 0; ++ ++ while (i < aLen) { ++ charCodeCache[start + i] = a.charCodeAt(start + i); ++ arr[i] = ++i; ++ } ++ ++ while (j < bLen) { ++ bCharCode = b.charCodeAt(start + j); ++ tmp = j++; ++ ret = j; ++ ++ for (i = 0; i < aLen; i++) { ++ tmp2 = bCharCode === charCodeCache[start + i] ? tmp : tmp + 1; ++ tmp = arr[i]; ++ ret = arr[i] = tmp > ret ? tmp2 > ret ? ret + 1 : tmp2 : tmp2 > tmp ? tmp + 1 : tmp2; ++ } ++ } ++ ++ return ret; ++}; ++ ++var leven_1 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ exports.levenUnknownHandler = (key, value, { ++ descriptor, ++ logger, ++ schemas ++ }) => { ++ const messages = [`Ignored unknown option ${chalk.default.yellow(descriptor.pair({ ++ key, ++ value ++ }))}.`]; ++ const suggestion = Object.keys(schemas).sort().find(knownKey => leven(key, knownKey) < 3); ++ ++ if (suggestion) { ++ messages.push(`Did you mean ${chalk.default.blue(descriptor.key(suggestion))}?`); ++ } ++ ++ logger.warn(messages.join(' ')); ++ }; ++}); ++unwrapExports(leven_1); ++var leven_2 = leven_1.levenUnknownHandler; ++ ++var unknown = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ tslib_1.__exportStar(leven_1, exports); ++}); ++unwrapExports(unknown); ++ ++var handlers = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ tslib_1.__exportStar(deprecated, exports); ++ ++ tslib_1.__exportStar(invalid, exports); ++ ++ tslib_1.__exportStar(unknown, exports); ++}); ++unwrapExports(handlers); ++ ++var schema = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ const HANDLER_KEYS = ['default', 'expected', 'validate', 'deprecated', 'forward', 'redirect', 'overlap', 'preprocess', 'postprocess']; ++ ++ function createSchema(SchemaConstructor, parameters) { ++ const schema = new SchemaConstructor(parameters); ++ const subSchema = Object.create(schema); ++ ++ for (const handlerKey of HANDLER_KEYS) { ++ if (handlerKey in parameters) { ++ subSchema[handlerKey] = normalizeHandler(parameters[handlerKey], schema, Schema.prototype[handlerKey].length); ++ } ++ } ++ ++ return subSchema; ++ } ++ ++ exports.createSchema = createSchema; ++ ++ class Schema { ++ constructor(parameters) { ++ this.name = parameters.name; ++ } ++ ++ static create(parameters) { ++ // @ts-ignore: https://github.com/Microsoft/TypeScript/issues/5863 ++ return createSchema(this, parameters); ++ } ++ ++ default(_utils) { ++ return undefined; ++ } // istanbul ignore next: this is actually an abstract method but we need a placeholder to get `function.length` ++ ++ ++ expected(_utils) { ++ return 'nothing'; ++ } // istanbul ignore next: this is actually an abstract method but we need a placeholder to get `function.length` ++ ++ ++ validate(_value, _utils) { ++ return false; ++ } ++ ++ deprecated(_value, _utils) { ++ return false; ++ } ++ ++ forward(_value, _utils) { ++ return undefined; ++ } ++ ++ redirect(_value, _utils) { ++ return undefined; ++ } ++ ++ overlap(currentValue, _newValue, _utils) { ++ return currentValue; ++ } ++ ++ preprocess(value, _utils) { ++ return value; ++ } ++ ++ postprocess(value, _utils) { ++ return value; ++ } ++ ++ } ++ ++ exports.Schema = Schema; ++ ++ function normalizeHandler(handler, superSchema, handlerArgumentsLength) { ++ return typeof handler === 'function' ? (...args) => handler(...args.slice(0, handlerArgumentsLength - 1), superSchema, ...args.slice(handlerArgumentsLength - 1)) : () => handler; ++ } ++}); ++unwrapExports(schema); ++var schema_1 = schema.createSchema; ++var schema_2 = schema.Schema; ++ ++var alias = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class AliasSchema extends schema.Schema { ++ constructor(parameters) { ++ super(parameters); ++ this._sourceName = parameters.sourceName; ++ } ++ ++ expected(utils) { ++ return utils.schemas[this._sourceName].expected(utils); ++ } ++ ++ validate(value, utils) { ++ return utils.schemas[this._sourceName].validate(value, utils); ++ } ++ ++ redirect(_value, _utils) { ++ return this._sourceName; ++ } ++ ++ } ++ ++ exports.AliasSchema = AliasSchema; ++}); ++unwrapExports(alias); ++var alias_1 = alias.AliasSchema; ++ ++var any = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class AnySchema extends schema.Schema { ++ expected() { ++ return 'anything'; ++ } ++ ++ validate() { ++ return true; ++ } ++ ++ } ++ ++ exports.AnySchema = AnySchema; ++}); ++unwrapExports(any); ++var any_1 = any.AnySchema; ++ ++var array = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class ArraySchema extends schema.Schema { ++ constructor(_a) { ++ var { ++ valueSchema, ++ name = valueSchema.name ++ } = _a, ++ handlers = tslib_1.__rest(_a, ["valueSchema", "name"]); ++ ++ super(Object.assign({}, handlers, { ++ name ++ })); ++ this._valueSchema = valueSchema; ++ } ++ ++ expected(utils) { ++ return `an array of ${this._valueSchema.expected(utils)}`; ++ } ++ ++ validate(value, utils) { ++ if (!Array.isArray(value)) { ++ return false; ++ } ++ ++ const invalidValues = []; ++ ++ for (const subValue of value) { ++ const subValidateResult = utils.normalizeValidateResult(this._valueSchema.validate(subValue, utils), subValue); ++ ++ if (subValidateResult !== true) { ++ invalidValues.push(subValidateResult.value); ++ } ++ } ++ ++ return invalidValues.length === 0 ? true : { ++ value: invalidValues ++ }; ++ } ++ ++ deprecated(value, utils) { ++ const deprecatedResult = []; ++ ++ for (const subValue of value) { ++ const subDeprecatedResult = utils.normalizeDeprecatedResult(this._valueSchema.deprecated(subValue, utils), subValue); ++ ++ if (subDeprecatedResult !== false) { ++ deprecatedResult.push(...subDeprecatedResult.map(({ ++ value: deprecatedValue ++ }) => ({ ++ value: [deprecatedValue] ++ }))); ++ } ++ } ++ ++ return deprecatedResult; ++ } ++ ++ forward(value, utils) { ++ const forwardResult = []; ++ ++ for (const subValue of value) { ++ const subForwardResult = utils.normalizeForwardResult(this._valueSchema.forward(subValue, utils), subValue); ++ forwardResult.push(...subForwardResult.map(wrapTransferResult)); ++ } ++ ++ return forwardResult; ++ } ++ ++ redirect(value, utils) { ++ const remain = []; ++ const redirect = []; ++ ++ for (const subValue of value) { ++ const subRedirectResult = utils.normalizeRedirectResult(this._valueSchema.redirect(subValue, utils), subValue); ++ ++ if ('remain' in subRedirectResult) { ++ remain.push(subRedirectResult.remain); ++ } ++ ++ redirect.push(...subRedirectResult.redirect.map(wrapTransferResult)); ++ } ++ ++ return remain.length === 0 ? { ++ redirect ++ } : { ++ redirect, ++ remain ++ }; ++ } ++ ++ overlap(currentValue, newValue) { ++ return currentValue.concat(newValue); ++ } ++ ++ } ++ ++ exports.ArraySchema = ArraySchema; ++ ++ function wrapTransferResult({ ++ from, ++ to ++ }) { ++ return { ++ from: [from], ++ to ++ }; ++ } ++}); ++unwrapExports(array); ++var array_1 = array.ArraySchema; ++ ++var boolean_1 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class BooleanSchema extends schema.Schema { ++ expected() { ++ return 'true or false'; ++ } ++ ++ validate(value) { ++ return typeof value === 'boolean'; ++ } ++ ++ } ++ ++ exports.BooleanSchema = BooleanSchema; ++}); ++unwrapExports(boolean_1); ++var boolean_2 = boolean_1.BooleanSchema; ++ ++var utils = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ function recordFromArray(array, mainKey) { ++ const record = Object.create(null); ++ ++ for (const value of array) { ++ const key = value[mainKey]; // istanbul ignore next ++ ++ if (record[key]) { ++ throw new Error(`Duplicate ${mainKey} ${JSON.stringify(key)}`); ++ } // @ts-ignore ++ ++ ++ record[key] = value; ++ } ++ ++ return record; ++ } ++ ++ exports.recordFromArray = recordFromArray; ++ ++ function mapFromArray(array, mainKey) { ++ const map = new Map(); ++ ++ for (const value of array) { ++ const key = value[mainKey]; // istanbul ignore next ++ ++ if (map.has(key)) { ++ throw new Error(`Duplicate ${mainKey} ${JSON.stringify(key)}`); ++ } ++ ++ map.set(key, value); ++ } ++ ++ return map; ++ } ++ ++ exports.mapFromArray = mapFromArray; ++ ++ function createAutoChecklist() { ++ const map = Object.create(null); ++ return id => { ++ const idString = JSON.stringify(id); ++ ++ if (map[idString]) { ++ return true; ++ } ++ ++ map[idString] = true; ++ return false; ++ }; ++ } ++ ++ exports.createAutoChecklist = createAutoChecklist; ++ ++ function partition(array, predicate) { ++ const trueArray = []; ++ const falseArray = []; ++ ++ for (const value of array) { ++ if (predicate(value)) { ++ trueArray.push(value); ++ } else { ++ falseArray.push(value); ++ } ++ } ++ ++ return [trueArray, falseArray]; ++ } ++ ++ exports.partition = partition; ++ ++ function isInt(value) { ++ return value === Math.floor(value); ++ } ++ ++ exports.isInt = isInt; ++ ++ function comparePrimitive(a, b) { ++ if (a === b) { ++ return 0; ++ } ++ ++ const typeofA = typeof a; ++ const typeofB = typeof b; ++ const orders = ['undefined', 'object', 'boolean', 'number', 'string']; ++ ++ if (typeofA !== typeofB) { ++ return orders.indexOf(typeofA) - orders.indexOf(typeofB); ++ } ++ ++ if (typeofA !== 'string') { ++ return Number(a) - Number(b); ++ } ++ ++ return a.localeCompare(b); ++ } ++ ++ exports.comparePrimitive = comparePrimitive; ++ ++ function normalizeDefaultResult(result) { ++ return result === undefined ? {} : result; ++ } ++ ++ exports.normalizeDefaultResult = normalizeDefaultResult; ++ ++ function normalizeValidateResult(result, value) { ++ return result === true ? true : result === false ? { ++ value ++ } : result; ++ } ++ ++ exports.normalizeValidateResult = normalizeValidateResult; ++ ++ function normalizeDeprecatedResult(result, value, doNotNormalizeTrue = false) { ++ return result === false ? false : result === true ? doNotNormalizeTrue ? true : [{ ++ value ++ }] : 'value' in result ? [result] : result.length === 0 ? false : result; ++ } ++ ++ exports.normalizeDeprecatedResult = normalizeDeprecatedResult; ++ ++ function normalizeTransferResult(result, value) { ++ return typeof result === 'string' || 'key' in result ? { ++ from: value, ++ to: result ++ } : 'from' in result ? { ++ from: result.from, ++ to: result.to ++ } : { ++ from: value, ++ to: result.to ++ }; ++ } ++ ++ exports.normalizeTransferResult = normalizeTransferResult; ++ ++ function normalizeForwardResult(result, value) { ++ return result === undefined ? [] : Array.isArray(result) ? result.map(transferResult => normalizeTransferResult(transferResult, value)) : [normalizeTransferResult(result, value)]; ++ } ++ ++ exports.normalizeForwardResult = normalizeForwardResult; ++ ++ function normalizeRedirectResult(result, value) { ++ const redirect = normalizeForwardResult(typeof result === 'object' && 'redirect' in result ? result.redirect : result, value); ++ return redirect.length === 0 ? { ++ remain: value, ++ redirect ++ } : typeof result === 'object' && 'remain' in result ? { ++ remain: result.remain, ++ redirect ++ } : { ++ redirect ++ }; ++ } ++ ++ exports.normalizeRedirectResult = normalizeRedirectResult; ++}); ++unwrapExports(utils); ++var utils_1 = utils.recordFromArray; ++var utils_2 = utils.mapFromArray; ++var utils_3 = utils.createAutoChecklist; ++var utils_4 = utils.partition; ++var utils_5 = utils.isInt; ++var utils_6 = utils.comparePrimitive; ++var utils_7 = utils.normalizeDefaultResult; ++var utils_8 = utils.normalizeValidateResult; ++var utils_9 = utils.normalizeDeprecatedResult; ++var utils_10 = utils.normalizeTransferResult; ++var utils_11 = utils.normalizeForwardResult; ++var utils_12 = utils.normalizeRedirectResult; ++ ++var choice = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class ChoiceSchema extends schema.Schema { ++ constructor(parameters) { ++ super(parameters); ++ this._choices = utils.mapFromArray(parameters.choices.map(choice => choice && typeof choice === 'object' ? choice : { ++ value: choice ++ }), 'value'); ++ } ++ ++ expected({ ++ descriptor ++ }) { ++ const choiceValues = Array.from(this._choices.keys()).map(value => this._choices.get(value)).filter(choiceInfo => !choiceInfo.deprecated).map(choiceInfo => choiceInfo.value).sort(utils.comparePrimitive).map(descriptor.value); ++ const head = choiceValues.slice(0, -2); ++ const tail = choiceValues.slice(-2); ++ return head.concat(tail.join(' or ')).join(', '); ++ } ++ ++ validate(value) { ++ return this._choices.has(value); ++ } ++ ++ deprecated(value) { ++ const choiceInfo = this._choices.get(value); ++ ++ return choiceInfo && choiceInfo.deprecated ? { ++ value ++ } : false; ++ } ++ ++ forward(value) { ++ const choiceInfo = this._choices.get(value); ++ ++ return choiceInfo ? choiceInfo.forward : undefined; ++ } ++ ++ redirect(value) { ++ const choiceInfo = this._choices.get(value); ++ ++ return choiceInfo ? choiceInfo.redirect : undefined; ++ } ++ ++ } ++ ++ exports.ChoiceSchema = ChoiceSchema; ++}); ++unwrapExports(choice); ++var choice_1 = choice.ChoiceSchema; ++ ++var number = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class NumberSchema extends schema.Schema { ++ expected() { ++ return 'a number'; ++ } ++ ++ validate(value, _utils) { ++ return typeof value === 'number'; ++ } ++ ++ } ++ ++ exports.NumberSchema = NumberSchema; ++}); ++unwrapExports(number); ++var number_1 = number.NumberSchema; ++ ++var integer = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class IntegerSchema extends number.NumberSchema { ++ expected() { ++ return 'an integer'; ++ } ++ ++ validate(value, utils$1) { ++ return utils$1.normalizeValidateResult(super.validate(value, utils$1), value) === true && utils.isInt(value); ++ } ++ ++ } ++ ++ exports.IntegerSchema = IntegerSchema; ++}); ++unwrapExports(integer); ++var integer_1 = integer.IntegerSchema; ++ ++var string = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class StringSchema extends schema.Schema { ++ expected() { ++ return 'a string'; ++ } ++ ++ validate(value) { ++ return typeof value === 'string'; ++ } ++ ++ } ++ ++ exports.StringSchema = StringSchema; ++}); ++unwrapExports(string); ++var string_1 = string.StringSchema; ++ ++var schemas = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ tslib_1.__exportStar(alias, exports); ++ ++ tslib_1.__exportStar(any, exports); ++ ++ tslib_1.__exportStar(array, exports); ++ ++ tslib_1.__exportStar(boolean_1, exports); ++ ++ tslib_1.__exportStar(choice, exports); ++ ++ tslib_1.__exportStar(integer, exports); ++ ++ tslib_1.__exportStar(number, exports); ++ ++ tslib_1.__exportStar(string, exports); ++}); ++unwrapExports(schemas); ++ ++var defaults = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ exports.defaultDescriptor = api.apiDescriptor; ++ exports.defaultUnknownHandler = leven_1.levenUnknownHandler; ++ exports.defaultInvalidHandler = invalid.commonInvalidHandler; ++ exports.defaultDeprecatedHandler = common.commonDeprecatedHandler; ++}); ++unwrapExports(defaults); ++var defaults_1 = defaults.defaultDescriptor; ++var defaults_2 = defaults.defaultUnknownHandler; ++var defaults_3 = defaults.defaultInvalidHandler; ++var defaults_4 = defaults.defaultDeprecatedHandler; ++ ++var normalize = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ exports.normalize = (options, schemas, opts) => new Normalizer(schemas, opts).normalize(options); ++ ++ class Normalizer { ++ constructor(schemas, opts) { ++ // istanbul ignore next ++ const { ++ logger = console, ++ descriptor = defaults.defaultDescriptor, ++ unknown = defaults.defaultUnknownHandler, ++ invalid = defaults.defaultInvalidHandler, ++ deprecated = defaults.defaultDeprecatedHandler ++ } = opts || {}; ++ this._utils = { ++ descriptor, ++ logger: ++ /* istanbul ignore next */ ++ logger || { ++ warn: () => {} ++ }, ++ schemas: utils.recordFromArray(schemas, 'name'), ++ normalizeDefaultResult: utils.normalizeDefaultResult, ++ normalizeDeprecatedResult: utils.normalizeDeprecatedResult, ++ normalizeForwardResult: utils.normalizeForwardResult, ++ normalizeRedirectResult: utils.normalizeRedirectResult, ++ normalizeValidateResult: utils.normalizeValidateResult ++ }; ++ this._unknownHandler = unknown; ++ this._invalidHandler = invalid; ++ this._deprecatedHandler = deprecated; ++ this.cleanHistory(); ++ } ++ ++ cleanHistory() { ++ this._hasDeprecationWarned = utils.createAutoChecklist(); ++ } ++ ++ normalize(options) { ++ const normalized = {}; ++ const restOptionsArray = [options]; ++ ++ const applyNormalization = () => { ++ while (restOptionsArray.length !== 0) { ++ const currentOptions = restOptionsArray.shift(); ++ ++ const transferredOptionsArray = this._applyNormalization(currentOptions, normalized); ++ ++ restOptionsArray.push(...transferredOptionsArray); ++ } ++ }; ++ ++ applyNormalization(); ++ ++ for (const key of Object.keys(this._utils.schemas)) { ++ const schema = this._utils.schemas[key]; ++ ++ if (!(key in normalized)) { ++ const defaultResult = utils.normalizeDefaultResult(schema.default(this._utils)); ++ ++ if ('value' in defaultResult) { ++ restOptionsArray.push({ ++ [key]: defaultResult.value ++ }); ++ } ++ } ++ } ++ ++ applyNormalization(); ++ ++ for (const key of Object.keys(this._utils.schemas)) { ++ const schema = this._utils.schemas[key]; ++ ++ if (key in normalized) { ++ normalized[key] = schema.postprocess(normalized[key], this._utils); ++ } ++ } ++ ++ return normalized; ++ } ++ ++ _applyNormalization(options, normalized) { ++ const transferredOptionsArray = []; ++ const [knownOptionNames, unknownOptionNames] = utils.partition(Object.keys(options), key => key in this._utils.schemas); ++ ++ for (const key of knownOptionNames) { ++ const schema = this._utils.schemas[key]; ++ const value = schema.preprocess(options[key], this._utils); ++ const validateResult = utils.normalizeValidateResult(schema.validate(value, this._utils), value); ++ ++ if (validateResult !== true) { ++ const { ++ value: invalidValue ++ } = validateResult; ++ ++ const errorMessageOrError = this._invalidHandler(key, invalidValue, this._utils); ++ ++ throw typeof errorMessageOrError === 'string' ? new Error(errorMessageOrError) : ++ /* istanbul ignore next*/ ++ errorMessageOrError; ++ } ++ ++ const appendTransferredOptions = ({ ++ from, ++ to ++ }) => { ++ transferredOptionsArray.push(typeof to === 'string' ? { ++ [to]: from ++ } : { ++ [to.key]: to.value ++ }); ++ }; ++ ++ const warnDeprecated = ({ ++ value: currentValue, ++ redirectTo ++ }) => { ++ const deprecatedResult = utils.normalizeDeprecatedResult(schema.deprecated(currentValue, this._utils), value, ++ /* doNotNormalizeTrue */ ++ true); ++ ++ if (deprecatedResult === false) { ++ return; ++ } ++ ++ if (deprecatedResult === true) { ++ if (!this._hasDeprecationWarned(key)) { ++ this._utils.logger.warn(this._deprecatedHandler(key, redirectTo, this._utils)); ++ } ++ } else { ++ for (const { ++ value: deprecatedValue ++ } of deprecatedResult) { ++ const pair = { ++ key, ++ value: deprecatedValue ++ }; ++ ++ if (!this._hasDeprecationWarned(pair)) { ++ const redirectToPair = typeof redirectTo === 'string' ? { ++ key: redirectTo, ++ value: deprecatedValue ++ } : redirectTo; ++ ++ this._utils.logger.warn(this._deprecatedHandler(pair, redirectToPair, this._utils)); ++ } ++ } ++ } ++ }; ++ ++ const forwardResult = utils.normalizeForwardResult(schema.forward(value, this._utils), value); ++ forwardResult.forEach(appendTransferredOptions); ++ const redirectResult = utils.normalizeRedirectResult(schema.redirect(value, this._utils), value); ++ redirectResult.redirect.forEach(appendTransferredOptions); ++ ++ if ('remain' in redirectResult) { ++ const remainingValue = redirectResult.remain; ++ normalized[key] = key in normalized ? schema.overlap(normalized[key], remainingValue, this._utils) : remainingValue; ++ warnDeprecated({ ++ value: remainingValue ++ }); ++ } ++ ++ for (const { ++ from, ++ to ++ } of redirectResult.redirect) { ++ warnDeprecated({ ++ value: from, ++ redirectTo: to ++ }); ++ } ++ } ++ ++ for (const key of unknownOptionNames) { ++ const value = options[key]; ++ ++ const unknownResult = this._unknownHandler(key, value, this._utils); ++ ++ if (unknownResult) { ++ for (const unknownKey of Object.keys(unknownResult)) { ++ const unknownOption = { ++ [unknownKey]: unknownResult[unknownKey] ++ }; ++ ++ if (unknownKey in this._utils.schemas) { ++ transferredOptionsArray.push(unknownOption); ++ } else { ++ Object.assign(normalized, unknownOption); ++ } ++ } ++ } ++ } ++ ++ return transferredOptionsArray; ++ } ++ ++ } ++ ++ exports.Normalizer = Normalizer; ++}); ++unwrapExports(normalize); ++var normalize_1 = normalize.normalize; ++var normalize_2 = normalize.Normalizer; ++ ++var lib = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ tslib_1.__exportStar(descriptors, exports); ++ ++ tslib_1.__exportStar(handlers, exports); ++ ++ tslib_1.__exportStar(schemas, exports); ++ ++ tslib_1.__exportStar(normalize, exports); ++ ++ tslib_1.__exportStar(schema, exports); ++}); ++unwrapExports(lib); ++ ++const array$1 = []; ++const charCodeCache$1 = []; ++ ++const leven$1 = (left, right) => { ++ if (left === right) { ++ return 0; ++ } ++ ++ const swap = left; // Swapping the strings if `a` is longer than `b` so we know which one is the ++ // shortest & which one is the longest ++ ++ if (left.length > right.length) { ++ left = right; ++ right = swap; ++ } ++ ++ let leftLength = left.length; ++ let rightLength = right.length; // Performing suffix trimming: ++ // We can linearly drop suffix common to both strings since they ++ // don't increase distance at all ++ // Note: `~-` is the bitwise way to perform a `- 1` operation ++ ++ while (leftLength > 0 && left.charCodeAt(~-leftLength) === right.charCodeAt(~-rightLength)) { ++ leftLength--; ++ rightLength--; ++ } // Performing prefix trimming ++ // We can linearly drop prefix common to both strings since they ++ // don't increase distance at all ++ ++ ++ let start = 0; ++ ++ while (start < leftLength && left.charCodeAt(start) === right.charCodeAt(start)) { ++ start++; ++ } ++ ++ leftLength -= start; ++ rightLength -= start; ++ ++ if (leftLength === 0) { ++ return rightLength; ++ } ++ ++ let bCharCode; ++ let result; ++ let temp; ++ let temp2; ++ let i = 0; ++ let j = 0; ++ ++ while (i < leftLength) { ++ charCodeCache$1[i] = left.charCodeAt(start + i); ++ array$1[i] = ++i; ++ } ++ ++ while (j < rightLength) { ++ bCharCode = right.charCodeAt(start + j); ++ temp = j++; ++ result = j; ++ ++ for (i = 0; i < leftLength; i++) { ++ temp2 = bCharCode === charCodeCache$1[i] ? temp : temp + 1; ++ temp = array$1[i]; // eslint-disable-next-line no-multi-assign ++ ++ result = array$1[i] = temp > result ? temp2 > result ? result + 1 : temp2 : temp2 > temp ? temp + 1 : temp2; ++ } ++ } ++ ++ return result; ++}; ++ ++var leven_1$1 = leven$1; // TODO: Remove this for the next major release ++ ++var default_1 = leven$1; ++leven_1$1.default = default_1; ++ ++var colorName$1 = { ++ "aliceblue": [240, 248, 255], ++ "antiquewhite": [250, 235, 215], ++ "aqua": [0, 255, 255], ++ "aquamarine": [127, 255, 212], ++ "azure": [240, 255, 255], ++ "beige": [245, 245, 220], ++ "bisque": [255, 228, 196], ++ "black": [0, 0, 0], ++ "blanchedalmond": [255, 235, 205], ++ "blue": [0, 0, 255], ++ "blueviolet": [138, 43, 226], ++ "brown": [165, 42, 42], ++ "burlywood": [222, 184, 135], ++ "cadetblue": [95, 158, 160], ++ "chartreuse": [127, 255, 0], ++ "chocolate": [210, 105, 30], ++ "coral": [255, 127, 80], ++ "cornflowerblue": [100, 149, 237], ++ "cornsilk": [255, 248, 220], ++ "crimson": [220, 20, 60], ++ "cyan": [0, 255, 255], ++ "darkblue": [0, 0, 139], ++ "darkcyan": [0, 139, 139], ++ "darkgoldenrod": [184, 134, 11], ++ "darkgray": [169, 169, 169], ++ "darkgreen": [0, 100, 0], ++ "darkgrey": [169, 169, 169], ++ "darkkhaki": [189, 183, 107], ++ "darkmagenta": [139, 0, 139], ++ "darkolivegreen": [85, 107, 47], ++ "darkorange": [255, 140, 0], ++ "darkorchid": [153, 50, 204], ++ "darkred": [139, 0, 0], ++ "darksalmon": [233, 150, 122], ++ "darkseagreen": [143, 188, 143], ++ "darkslateblue": [72, 61, 139], ++ "darkslategray": [47, 79, 79], ++ "darkslategrey": [47, 79, 79], ++ "darkturquoise": [0, 206, 209], ++ "darkviolet": [148, 0, 211], ++ "deeppink": [255, 20, 147], ++ "deepskyblue": [0, 191, 255], ++ "dimgray": [105, 105, 105], ++ "dimgrey": [105, 105, 105], ++ "dodgerblue": [30, 144, 255], ++ "firebrick": [178, 34, 34], ++ "floralwhite": [255, 250, 240], ++ "forestgreen": [34, 139, 34], ++ "fuchsia": [255, 0, 255], ++ "gainsboro": [220, 220, 220], ++ "ghostwhite": [248, 248, 255], ++ "gold": [255, 215, 0], ++ "goldenrod": [218, 165, 32], ++ "gray": [128, 128, 128], ++ "green": [0, 128, 0], ++ "greenyellow": [173, 255, 47], ++ "grey": [128, 128, 128], ++ "honeydew": [240, 255, 240], ++ "hotpink": [255, 105, 180], ++ "indianred": [205, 92, 92], ++ "indigo": [75, 0, 130], ++ "ivory": [255, 255, 240], ++ "khaki": [240, 230, 140], ++ "lavender": [230, 230, 250], ++ "lavenderblush": [255, 240, 245], ++ "lawngreen": [124, 252, 0], ++ "lemonchiffon": [255, 250, 205], ++ "lightblue": [173, 216, 230], ++ "lightcoral": [240, 128, 128], ++ "lightcyan": [224, 255, 255], ++ "lightgoldenrodyellow": [250, 250, 210], ++ "lightgray": [211, 211, 211], ++ "lightgreen": [144, 238, 144], ++ "lightgrey": [211, 211, 211], ++ "lightpink": [255, 182, 193], ++ "lightsalmon": [255, 160, 122], ++ "lightseagreen": [32, 178, 170], ++ "lightskyblue": [135, 206, 250], ++ "lightslategray": [119, 136, 153], ++ "lightslategrey": [119, 136, 153], ++ "lightsteelblue": [176, 196, 222], ++ "lightyellow": [255, 255, 224], ++ "lime": [0, 255, 0], ++ "limegreen": [50, 205, 50], ++ "linen": [250, 240, 230], ++ "magenta": [255, 0, 255], ++ "maroon": [128, 0, 0], ++ "mediumaquamarine": [102, 205, 170], ++ "mediumblue": [0, 0, 205], ++ "mediumorchid": [186, 85, 211], ++ "mediumpurple": [147, 112, 219], ++ "mediumseagreen": [60, 179, 113], ++ "mediumslateblue": [123, 104, 238], ++ "mediumspringgreen": [0, 250, 154], ++ "mediumturquoise": [72, 209, 204], ++ "mediumvioletred": [199, 21, 133], ++ "midnightblue": [25, 25, 112], ++ "mintcream": [245, 255, 250], ++ "mistyrose": [255, 228, 225], ++ "moccasin": [255, 228, 181], ++ "navajowhite": [255, 222, 173], ++ "navy": [0, 0, 128], ++ "oldlace": [253, 245, 230], ++ "olive": [128, 128, 0], ++ "olivedrab": [107, 142, 35], ++ "orange": [255, 165, 0], ++ "orangered": [255, 69, 0], ++ "orchid": [218, 112, 214], ++ "palegoldenrod": [238, 232, 170], ++ "palegreen": [152, 251, 152], ++ "paleturquoise": [175, 238, 238], ++ "palevioletred": [219, 112, 147], ++ "papayawhip": [255, 239, 213], ++ "peachpuff": [255, 218, 185], ++ "peru": [205, 133, 63], ++ "pink": [255, 192, 203], ++ "plum": [221, 160, 221], ++ "powderblue": [176, 224, 230], ++ "purple": [128, 0, 128], ++ "rebeccapurple": [102, 51, 153], ++ "red": [255, 0, 0], ++ "rosybrown": [188, 143, 143], ++ "royalblue": [65, 105, 225], ++ "saddlebrown": [139, 69, 19], ++ "salmon": [250, 128, 114], ++ "sandybrown": [244, 164, 96], ++ "seagreen": [46, 139, 87], ++ "seashell": [255, 245, 238], ++ "sienna": [160, 82, 45], ++ "silver": [192, 192, 192], ++ "skyblue": [135, 206, 235], ++ "slateblue": [106, 90, 205], ++ "slategray": [112, 128, 144], ++ "slategrey": [112, 128, 144], ++ "snow": [255, 250, 250], ++ "springgreen": [0, 255, 127], ++ "steelblue": [70, 130, 180], ++ "tan": [210, 180, 140], ++ "teal": [0, 128, 128], ++ "thistle": [216, 191, 216], ++ "tomato": [255, 99, 71], ++ "turquoise": [64, 224, 208], ++ "violet": [238, 130, 238], ++ "wheat": [245, 222, 179], ++ "white": [255, 255, 255], ++ "whitesmoke": [245, 245, 245], ++ "yellow": [255, 255, 0], ++ "yellowgreen": [154, 205, 50] ++}; ++ ++/* MIT license */ ++ ++/* eslint-disable no-mixed-operators */ ++// NOTE: conversions should only return primitive values (i.e. arrays, or ++// values that give correct `typeof` results). ++// do not use box values types (i.e. Number(), String(), etc.) ++ ++const reverseKeywords = {}; ++ ++for (const key of Object.keys(colorName$1)) { ++ reverseKeywords[colorName$1[key]] = key; ++} ++ ++const convert$1 = { ++ rgb: { ++ channels: 3, ++ labels: 'rgb' ++ }, ++ hsl: { ++ channels: 3, ++ labels: 'hsl' ++ }, ++ hsv: { ++ channels: 3, ++ labels: 'hsv' ++ }, ++ hwb: { ++ channels: 3, ++ labels: 'hwb' ++ }, ++ cmyk: { ++ channels: 4, ++ labels: 'cmyk' ++ }, ++ xyz: { ++ channels: 3, ++ labels: 'xyz' ++ }, ++ lab: { ++ channels: 3, ++ labels: 'lab' ++ }, ++ lch: { ++ channels: 3, ++ labels: 'lch' ++ }, ++ hex: { ++ channels: 1, ++ labels: ['hex'] ++ }, ++ keyword: { ++ channels: 1, ++ labels: ['keyword'] ++ }, ++ ansi16: { ++ channels: 1, ++ labels: ['ansi16'] ++ }, ++ ansi256: { ++ channels: 1, ++ labels: ['ansi256'] ++ }, ++ hcg: { ++ channels: 3, ++ labels: ['h', 'c', 'g'] ++ }, ++ apple: { ++ channels: 3, ++ labels: ['r16', 'g16', 'b16'] ++ }, ++ gray: { ++ channels: 1, ++ labels: ['gray'] ++ } ++}; ++var conversions$1 = convert$1; // Hide .channels and .labels properties ++ ++for (const model of Object.keys(convert$1)) { ++ if (!('channels' in convert$1[model])) { ++ throw new Error('missing channels property: ' + model); ++ } ++ ++ if (!('labels' in convert$1[model])) { ++ throw new Error('missing channel labels property: ' + model); ++ } ++ ++ if (convert$1[model].labels.length !== convert$1[model].channels) { ++ throw new Error('channel and label counts mismatch: ' + model); ++ } ++ ++ const { ++ channels, ++ labels ++ } = convert$1[model]; ++ delete convert$1[model].channels; ++ delete convert$1[model].labels; ++ Object.defineProperty(convert$1[model], 'channels', { ++ value: channels ++ }); ++ Object.defineProperty(convert$1[model], 'labels', { ++ value: labels ++ }); ++} ++ ++convert$1.rgb.hsl = function (rgb) { ++ const r = rgb[0] / 255; ++ const g = rgb[1] / 255; ++ const b = rgb[2] / 255; ++ const min = Math.min(r, g, b); ++ const max = Math.max(r, g, b); ++ const delta = max - min; ++ let h; ++ let s; ++ ++ if (max === min) { ++ h = 0; ++ } else if (r === max) { ++ h = (g - b) / delta; ++ } else if (g === max) { ++ h = 2 + (b - r) / delta; ++ } else if (b === max) { ++ h = 4 + (r - g) / delta; ++ } ++ ++ h = Math.min(h * 60, 360); ++ ++ if (h < 0) { ++ h += 360; ++ } ++ ++ const l = (min + max) / 2; ++ ++ if (max === min) { ++ s = 0; ++ } else if (l <= 0.5) { ++ s = delta / (max + min); ++ } else { ++ s = delta / (2 - max - min); ++ } ++ ++ return [h, s * 100, l * 100]; ++}; ++ ++convert$1.rgb.hsv = function (rgb) { ++ let rdif; ++ let gdif; ++ let bdif; ++ let h; ++ let s; ++ const r = rgb[0] / 255; ++ const g = rgb[1] / 255; ++ const b = rgb[2] / 255; ++ const v = Math.max(r, g, b); ++ const diff = v - Math.min(r, g, b); ++ ++ const diffc = function (c) { ++ return (v - c) / 6 / diff + 1 / 2; ++ }; ++ ++ if (diff === 0) { ++ h = 0; ++ s = 0; ++ } else { ++ s = diff / v; ++ rdif = diffc(r); ++ gdif = diffc(g); ++ bdif = diffc(b); ++ ++ if (r === v) { ++ h = bdif - gdif; ++ } else if (g === v) { ++ h = 1 / 3 + rdif - bdif; ++ } else if (b === v) { ++ h = 2 / 3 + gdif - rdif; ++ } ++ ++ if (h < 0) { ++ h += 1; ++ } else if (h > 1) { ++ h -= 1; ++ } ++ } ++ ++ return [h * 360, s * 100, v * 100]; ++}; ++ ++convert$1.rgb.hwb = function (rgb) { ++ const r = rgb[0]; ++ const g = rgb[1]; ++ let b = rgb[2]; ++ const h = convert$1.rgb.hsl(rgb)[0]; ++ const w = 1 / 255 * Math.min(r, Math.min(g, b)); ++ b = 1 - 1 / 255 * Math.max(r, Math.max(g, b)); ++ return [h, w * 100, b * 100]; ++}; ++ ++convert$1.rgb.cmyk = function (rgb) { ++ const r = rgb[0] / 255; ++ const g = rgb[1] / 255; ++ const b = rgb[2] / 255; ++ const k = Math.min(1 - r, 1 - g, 1 - b); ++ const c = (1 - r - k) / (1 - k) || 0; ++ const m = (1 - g - k) / (1 - k) || 0; ++ const y = (1 - b - k) / (1 - k) || 0; ++ return [c * 100, m * 100, y * 100, k * 100]; ++}; ++ ++function comparativeDistance(x, y) { ++ /* ++ See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance ++ */ ++ return (x[0] - y[0]) ** 2 + (x[1] - y[1]) ** 2 + (x[2] - y[2]) ** 2; ++} ++ ++convert$1.rgb.keyword = function (rgb) { ++ const reversed = reverseKeywords[rgb]; ++ ++ if (reversed) { ++ return reversed; ++ } ++ ++ let currentClosestDistance = Infinity; ++ let currentClosestKeyword; ++ ++ for (const keyword of Object.keys(colorName$1)) { ++ const value = colorName$1[keyword]; // Compute comparative distance ++ ++ const distance = comparativeDistance(rgb, value); // Check if its less, if so set as closest ++ ++ if (distance < currentClosestDistance) { ++ currentClosestDistance = distance; ++ currentClosestKeyword = keyword; ++ } ++ } ++ ++ return currentClosestKeyword; ++}; ++ ++convert$1.keyword.rgb = function (keyword) { ++ return colorName$1[keyword]; ++}; ++ ++convert$1.rgb.xyz = function (rgb) { ++ let r = rgb[0] / 255; ++ let g = rgb[1] / 255; ++ let b = rgb[2] / 255; // Assume sRGB ++ ++ r = r > 0.04045 ? ((r + 0.055) / 1.055) ** 2.4 : r / 12.92; ++ g = g > 0.04045 ? ((g + 0.055) / 1.055) ** 2.4 : g / 12.92; ++ b = b > 0.04045 ? ((b + 0.055) / 1.055) ** 2.4 : b / 12.92; ++ const x = r * 0.4124 + g * 0.3576 + b * 0.1805; ++ const y = r * 0.2126 + g * 0.7152 + b * 0.0722; ++ const z = r * 0.0193 + g * 0.1192 + b * 0.9505; ++ return [x * 100, y * 100, z * 100]; ++}; ++ ++convert$1.rgb.lab = function (rgb) { ++ const xyz = convert$1.rgb.xyz(rgb); ++ let x = xyz[0]; ++ let y = xyz[1]; ++ let z = xyz[2]; ++ x /= 95.047; ++ y /= 100; ++ z /= 108.883; ++ x = x > 0.008856 ? x ** (1 / 3) : 7.787 * x + 16 / 116; ++ y = y > 0.008856 ? y ** (1 / 3) : 7.787 * y + 16 / 116; ++ z = z > 0.008856 ? z ** (1 / 3) : 7.787 * z + 16 / 116; ++ const l = 116 * y - 16; ++ const a = 500 * (x - y); ++ const b = 200 * (y - z); ++ return [l, a, b]; ++}; ++ ++convert$1.hsl.rgb = function (hsl) { ++ const h = hsl[0] / 360; ++ const s = hsl[1] / 100; ++ const l = hsl[2] / 100; ++ let t2; ++ let t3; ++ let val; ++ ++ if (s === 0) { ++ val = l * 255; ++ return [val, val, val]; ++ } ++ ++ if (l < 0.5) { ++ t2 = l * (1 + s); ++ } else { ++ t2 = l + s - l * s; ++ } ++ ++ const t1 = 2 * l - t2; ++ const rgb = [0, 0, 0]; ++ ++ for (let i = 0; i < 3; i++) { ++ t3 = h + 1 / 3 * -(i - 1); ++ ++ if (t3 < 0) { ++ t3++; ++ } ++ ++ if (t3 > 1) { ++ t3--; ++ } ++ ++ if (6 * t3 < 1) { ++ val = t1 + (t2 - t1) * 6 * t3; ++ } else if (2 * t3 < 1) { ++ val = t2; ++ } else if (3 * t3 < 2) { ++ val = t1 + (t2 - t1) * (2 / 3 - t3) * 6; ++ } else { ++ val = t1; ++ } ++ ++ rgb[i] = val * 255; ++ } ++ ++ return rgb; ++}; ++ ++convert$1.hsl.hsv = function (hsl) { ++ const h = hsl[0]; ++ let s = hsl[1] / 100; ++ let l = hsl[2] / 100; ++ let smin = s; ++ const lmin = Math.max(l, 0.01); ++ l *= 2; ++ s *= l <= 1 ? l : 2 - l; ++ smin *= lmin <= 1 ? lmin : 2 - lmin; ++ const v = (l + s) / 2; ++ const sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l + s); ++ return [h, sv * 100, v * 100]; ++}; ++ ++convert$1.hsv.rgb = function (hsv) { ++ const h = hsv[0] / 60; ++ const s = hsv[1] / 100; ++ let v = hsv[2] / 100; ++ const hi = Math.floor(h) % 6; ++ const f = h - Math.floor(h); ++ const p = 255 * v * (1 - s); ++ const q = 255 * v * (1 - s * f); ++ const t = 255 * v * (1 - s * (1 - f)); ++ v *= 255; ++ ++ switch (hi) { ++ case 0: ++ return [v, t, p]; ++ ++ case 1: ++ return [q, v, p]; ++ ++ case 2: ++ return [p, v, t]; ++ ++ case 3: ++ return [p, q, v]; ++ ++ case 4: ++ return [t, p, v]; ++ ++ case 5: ++ return [v, p, q]; ++ } ++}; ++ ++convert$1.hsv.hsl = function (hsv) { ++ const h = hsv[0]; ++ const s = hsv[1] / 100; ++ const v = hsv[2] / 100; ++ const vmin = Math.max(v, 0.01); ++ let sl; ++ let l; ++ l = (2 - s) * v; ++ const lmin = (2 - s) * vmin; ++ sl = s * vmin; ++ sl /= lmin <= 1 ? lmin : 2 - lmin; ++ sl = sl || 0; ++ l /= 2; ++ return [h, sl * 100, l * 100]; ++}; // http://dev.w3.org/csswg/css-color/#hwb-to-rgb ++ ++ ++convert$1.hwb.rgb = function (hwb) { ++ const h = hwb[0] / 360; ++ let wh = hwb[1] / 100; ++ let bl = hwb[2] / 100; ++ const ratio = wh + bl; ++ let f; // Wh + bl cant be > 1 ++ ++ if (ratio > 1) { ++ wh /= ratio; ++ bl /= ratio; ++ } ++ ++ const i = Math.floor(6 * h); ++ const v = 1 - bl; ++ f = 6 * h - i; ++ ++ if ((i & 0x01) !== 0) { ++ f = 1 - f; ++ } ++ ++ const n = wh + f * (v - wh); // Linear interpolation ++ ++ let r; ++ let g; ++ let b; ++ /* eslint-disable max-statements-per-line,no-multi-spaces */ ++ ++ switch (i) { ++ default: ++ case 6: ++ case 0: ++ r = v; ++ g = n; ++ b = wh; ++ break; ++ ++ case 1: ++ r = n; ++ g = v; ++ b = wh; ++ break; ++ ++ case 2: ++ r = wh; ++ g = v; ++ b = n; ++ break; ++ ++ case 3: ++ r = wh; ++ g = n; ++ b = v; ++ break; ++ ++ case 4: ++ r = n; ++ g = wh; ++ b = v; ++ break; ++ ++ case 5: ++ r = v; ++ g = wh; ++ b = n; ++ break; ++ } ++ /* eslint-enable max-statements-per-line,no-multi-spaces */ ++ ++ ++ return [r * 255, g * 255, b * 255]; ++}; ++ ++convert$1.cmyk.rgb = function (cmyk) { ++ const c = cmyk[0] / 100; ++ const m = cmyk[1] / 100; ++ const y = cmyk[2] / 100; ++ const k = cmyk[3] / 100; ++ const r = 1 - Math.min(1, c * (1 - k) + k); ++ const g = 1 - Math.min(1, m * (1 - k) + k); ++ const b = 1 - Math.min(1, y * (1 - k) + k); ++ return [r * 255, g * 255, b * 255]; ++}; ++ ++convert$1.xyz.rgb = function (xyz) { ++ const x = xyz[0] / 100; ++ const y = xyz[1] / 100; ++ const z = xyz[2] / 100; ++ let r; ++ let g; ++ let b; ++ r = x * 3.2406 + y * -1.5372 + z * -0.4986; ++ g = x * -0.9689 + y * 1.8758 + z * 0.0415; ++ b = x * 0.0557 + y * -0.2040 + z * 1.0570; // Assume sRGB ++ ++ r = r > 0.0031308 ? 1.055 * r ** (1.0 / 2.4) - 0.055 : r * 12.92; ++ g = g > 0.0031308 ? 1.055 * g ** (1.0 / 2.4) - 0.055 : g * 12.92; ++ b = b > 0.0031308 ? 1.055 * b ** (1.0 / 2.4) - 0.055 : b * 12.92; ++ r = Math.min(Math.max(0, r), 1); ++ g = Math.min(Math.max(0, g), 1); ++ b = Math.min(Math.max(0, b), 1); ++ return [r * 255, g * 255, b * 255]; ++}; ++ ++convert$1.xyz.lab = function (xyz) { ++ let x = xyz[0]; ++ let y = xyz[1]; ++ let z = xyz[2]; ++ x /= 95.047; ++ y /= 100; ++ z /= 108.883; ++ x = x > 0.008856 ? x ** (1 / 3) : 7.787 * x + 16 / 116; ++ y = y > 0.008856 ? y ** (1 / 3) : 7.787 * y + 16 / 116; ++ z = z > 0.008856 ? z ** (1 / 3) : 7.787 * z + 16 / 116; ++ const l = 116 * y - 16; ++ const a = 500 * (x - y); ++ const b = 200 * (y - z); ++ return [l, a, b]; ++}; ++ ++convert$1.lab.xyz = function (lab) { ++ const l = lab[0]; ++ const a = lab[1]; ++ const b = lab[2]; ++ let x; ++ let y; ++ let z; ++ y = (l + 16) / 116; ++ x = a / 500 + y; ++ z = y - b / 200; ++ const y2 = y ** 3; ++ const x2 = x ** 3; ++ const z2 = z ** 3; ++ y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787; ++ x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787; ++ z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787; ++ x *= 95.047; ++ y *= 100; ++ z *= 108.883; ++ return [x, y, z]; ++}; ++ ++convert$1.lab.lch = function (lab) { ++ const l = lab[0]; ++ const a = lab[1]; ++ const b = lab[2]; ++ let h; ++ const hr = Math.atan2(b, a); ++ h = hr * 360 / 2 / Math.PI; ++ ++ if (h < 0) { ++ h += 360; ++ } ++ ++ const c = Math.sqrt(a * a + b * b); ++ return [l, c, h]; ++}; ++ ++convert$1.lch.lab = function (lch) { ++ const l = lch[0]; ++ const c = lch[1]; ++ const h = lch[2]; ++ const hr = h / 360 * 2 * Math.PI; ++ const a = c * Math.cos(hr); ++ const b = c * Math.sin(hr); ++ return [l, a, b]; ++}; ++ ++convert$1.rgb.ansi16 = function (args, saturation = null) { ++ const [r, g, b] = args; ++ let value = saturation === null ? convert$1.rgb.hsv(args)[2] : saturation; // Hsv -> ansi16 optimization ++ ++ value = Math.round(value / 50); ++ ++ if (value === 0) { ++ return 30; ++ } ++ ++ let ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255)); ++ ++ if (value === 2) { ++ ansi += 60; ++ } ++ ++ return ansi; ++}; ++ ++convert$1.hsv.ansi16 = function (args) { ++ // Optimization here; we already know the value and don't need to get ++ // it converted for us. ++ return convert$1.rgb.ansi16(convert$1.hsv.rgb(args), args[2]); ++}; ++ ++convert$1.rgb.ansi256 = function (args) { ++ const r = args[0]; ++ const g = args[1]; ++ const b = args[2]; // We use the extended greyscale palette here, with the exception of ++ // black and white. normal palette only has 4 greyscale shades. ++ ++ if (r === g && g === b) { ++ if (r < 8) { ++ return 16; ++ } ++ ++ if (r > 248) { ++ return 231; ++ } ++ ++ return Math.round((r - 8) / 247 * 24) + 232; ++ } ++ ++ const ansi = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5); ++ return ansi; ++}; ++ ++convert$1.ansi16.rgb = function (args) { ++ let color = args % 10; // Handle greyscale ++ ++ if (color === 0 || color === 7) { ++ if (args > 50) { ++ color += 3.5; ++ } ++ ++ color = color / 10.5 * 255; ++ return [color, color, color]; ++ } ++ ++ const mult = (~~(args > 50) + 1) * 0.5; ++ const r = (color & 1) * mult * 255; ++ const g = (color >> 1 & 1) * mult * 255; ++ const b = (color >> 2 & 1) * mult * 255; ++ return [r, g, b]; ++}; ++ ++convert$1.ansi256.rgb = function (args) { ++ // Handle greyscale ++ if (args >= 232) { ++ const c = (args - 232) * 10 + 8; ++ return [c, c, c]; ++ } ++ ++ args -= 16; ++ let rem; ++ const r = Math.floor(args / 36) / 5 * 255; ++ const g = Math.floor((rem = args % 36) / 6) / 5 * 255; ++ const b = rem % 6 / 5 * 255; ++ return [r, g, b]; ++}; ++ ++convert$1.rgb.hex = function (args) { ++ const integer = ((Math.round(args[0]) & 0xFF) << 16) + ((Math.round(args[1]) & 0xFF) << 8) + (Math.round(args[2]) & 0xFF); ++ const string = integer.toString(16).toUpperCase(); ++ return '000000'.substring(string.length) + string; ++}; ++ ++convert$1.hex.rgb = function (args) { ++ const match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i); ++ ++ if (!match) { ++ return [0, 0, 0]; ++ } ++ ++ let colorString = match[0]; ++ ++ if (match[0].length === 3) { ++ colorString = colorString.split('').map(char => { ++ return char + char; ++ }).join(''); ++ } ++ ++ const integer = parseInt(colorString, 16); ++ const r = integer >> 16 & 0xFF; ++ const g = integer >> 8 & 0xFF; ++ const b = integer & 0xFF; ++ return [r, g, b]; ++}; ++ ++convert$1.rgb.hcg = function (rgb) { ++ const r = rgb[0] / 255; ++ const g = rgb[1] / 255; ++ const b = rgb[2] / 255; ++ const max = Math.max(Math.max(r, g), b); ++ const min = Math.min(Math.min(r, g), b); ++ const chroma = max - min; ++ let grayscale; ++ let hue; ++ ++ if (chroma < 1) { ++ grayscale = min / (1 - chroma); ++ } else { ++ grayscale = 0; ++ } ++ ++ if (chroma <= 0) { ++ hue = 0; ++ } else if (max === r) { ++ hue = (g - b) / chroma % 6; ++ } else if (max === g) { ++ hue = 2 + (b - r) / chroma; ++ } else { ++ hue = 4 + (r - g) / chroma; ++ } ++ ++ hue /= 6; ++ hue %= 1; ++ return [hue * 360, chroma * 100, grayscale * 100]; ++}; ++ ++convert$1.hsl.hcg = function (hsl) { ++ const s = hsl[1] / 100; ++ const l = hsl[2] / 100; ++ const c = l < 0.5 ? 2.0 * s * l : 2.0 * s * (1.0 - l); ++ let f = 0; ++ ++ if (c < 1.0) { ++ f = (l - 0.5 * c) / (1.0 - c); ++ } ++ ++ return [hsl[0], c * 100, f * 100]; ++}; ++ ++convert$1.hsv.hcg = function (hsv) { ++ const s = hsv[1] / 100; ++ const v = hsv[2] / 100; ++ const c = s * v; ++ let f = 0; ++ ++ if (c < 1.0) { ++ f = (v - c) / (1 - c); ++ } ++ ++ return [hsv[0], c * 100, f * 100]; ++}; ++ ++convert$1.hcg.rgb = function (hcg) { ++ const h = hcg[0] / 360; ++ const c = hcg[1] / 100; ++ const g = hcg[2] / 100; ++ ++ if (c === 0.0) { ++ return [g * 255, g * 255, g * 255]; ++ } ++ ++ const pure = [0, 0, 0]; ++ const hi = h % 1 * 6; ++ const v = hi % 1; ++ const w = 1 - v; ++ let mg = 0; ++ /* eslint-disable max-statements-per-line */ ++ ++ switch (Math.floor(hi)) { ++ case 0: ++ pure[0] = 1; ++ pure[1] = v; ++ pure[2] = 0; ++ break; ++ ++ case 1: ++ pure[0] = w; ++ pure[1] = 1; ++ pure[2] = 0; ++ break; ++ ++ case 2: ++ pure[0] = 0; ++ pure[1] = 1; ++ pure[2] = v; ++ break; ++ ++ case 3: ++ pure[0] = 0; ++ pure[1] = w; ++ pure[2] = 1; ++ break; ++ ++ case 4: ++ pure[0] = v; ++ pure[1] = 0; ++ pure[2] = 1; ++ break; ++ ++ default: ++ pure[0] = 1; ++ pure[1] = 0; ++ pure[2] = w; ++ } ++ /* eslint-enable max-statements-per-line */ ++ ++ ++ mg = (1.0 - c) * g; ++ return [(c * pure[0] + mg) * 255, (c * pure[1] + mg) * 255, (c * pure[2] + mg) * 255]; ++}; ++ ++convert$1.hcg.hsv = function (hcg) { ++ const c = hcg[1] / 100; ++ const g = hcg[2] / 100; ++ const v = c + g * (1.0 - c); ++ let f = 0; ++ ++ if (v > 0.0) { ++ f = c / v; ++ } ++ ++ return [hcg[0], f * 100, v * 100]; ++}; ++ ++convert$1.hcg.hsl = function (hcg) { ++ const c = hcg[1] / 100; ++ const g = hcg[2] / 100; ++ const l = g * (1.0 - c) + 0.5 * c; ++ let s = 0; ++ ++ if (l > 0.0 && l < 0.5) { ++ s = c / (2 * l); ++ } else if (l >= 0.5 && l < 1.0) { ++ s = c / (2 * (1 - l)); ++ } ++ ++ return [hcg[0], s * 100, l * 100]; ++}; ++ ++convert$1.hcg.hwb = function (hcg) { ++ const c = hcg[1] / 100; ++ const g = hcg[2] / 100; ++ const v = c + g * (1.0 - c); ++ return [hcg[0], (v - c) * 100, (1 - v) * 100]; ++}; ++ ++convert$1.hwb.hcg = function (hwb) { ++ const w = hwb[1] / 100; ++ const b = hwb[2] / 100; ++ const v = 1 - b; ++ const c = v - w; ++ let g = 0; ++ ++ if (c < 1) { ++ g = (v - c) / (1 - c); ++ } ++ ++ return [hwb[0], c * 100, g * 100]; ++}; ++ ++convert$1.apple.rgb = function (apple) { ++ return [apple[0] / 65535 * 255, apple[1] / 65535 * 255, apple[2] / 65535 * 255]; ++}; ++ ++convert$1.rgb.apple = function (rgb) { ++ return [rgb[0] / 255 * 65535, rgb[1] / 255 * 65535, rgb[2] / 255 * 65535]; ++}; ++ ++convert$1.gray.rgb = function (args) { ++ return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255]; ++}; ++ ++convert$1.gray.hsl = function (args) { ++ return [0, 0, args[0]]; ++}; ++ ++convert$1.gray.hsv = convert$1.gray.hsl; ++ ++convert$1.gray.hwb = function (gray) { ++ return [0, 100, gray[0]]; ++}; ++ ++convert$1.gray.cmyk = function (gray) { ++ return [0, 0, 0, gray[0]]; ++}; ++ ++convert$1.gray.lab = function (gray) { ++ return [gray[0], 0, 0]; ++}; ++ ++convert$1.gray.hex = function (gray) { ++ const val = Math.round(gray[0] / 100 * 255) & 0xFF; ++ const integer = (val << 16) + (val << 8) + val; ++ const string = integer.toString(16).toUpperCase(); ++ return '000000'.substring(string.length) + string; ++}; ++ ++convert$1.rgb.gray = function (rgb) { ++ const val = (rgb[0] + rgb[1] + rgb[2]) / 3; ++ return [val / 255 * 100]; ++}; ++ ++/* ++ This function routes a model to all other models. ++ ++ all functions that are routed have a property `.conversion` attached ++ to the returned synthetic function. This property is an array ++ of strings, each with the steps in between the 'from' and 'to' ++ color models (inclusive). ++ ++ conversions that are not possible simply are not included. ++*/ ++ ++function buildGraph$1() { ++ const graph = {}; // https://jsperf.com/object-keys-vs-for-in-with-closure/3 ++ ++ const models = Object.keys(conversions$1); ++ ++ for (let len = models.length, i = 0; i < len; i++) { ++ graph[models[i]] = { ++ // http://jsperf.com/1-vs-infinity ++ // micro-opt, but this is simple. ++ distance: -1, ++ parent: null ++ }; ++ } ++ ++ return graph; ++} // https://en.wikipedia.org/wiki/Breadth-first_search ++ ++ ++function deriveBFS$1(fromModel) { ++ const graph = buildGraph$1(); ++ const queue = [fromModel]; // Unshift -> queue -> pop ++ ++ graph[fromModel].distance = 0; ++ ++ while (queue.length) { ++ const current = queue.pop(); ++ const adjacents = Object.keys(conversions$1[current]); ++ ++ for (let len = adjacents.length, i = 0; i < len; i++) { ++ const adjacent = adjacents[i]; ++ const node = graph[adjacent]; ++ ++ if (node.distance === -1) { ++ node.distance = graph[current].distance + 1; ++ node.parent = current; ++ queue.unshift(adjacent); ++ } ++ } ++ } ++ ++ return graph; ++} ++ ++function link$1(from, to) { ++ return function (args) { ++ return to(from(args)); ++ }; ++} ++ ++function wrapConversion$1(toModel, graph) { ++ const path = [graph[toModel].parent, toModel]; ++ let fn = conversions$1[graph[toModel].parent][toModel]; ++ let cur = graph[toModel].parent; ++ ++ while (graph[cur].parent) { ++ path.unshift(graph[cur].parent); ++ fn = link$1(conversions$1[graph[cur].parent][cur], fn); ++ cur = graph[cur].parent; ++ } ++ ++ fn.conversion = path; ++ return fn; ++} ++ ++var route$1 = function (fromModel) { ++ const graph = deriveBFS$1(fromModel); ++ const conversion = {}; ++ const models = Object.keys(graph); ++ ++ for (let len = models.length, i = 0; i < len; i++) { ++ const toModel = models[i]; ++ const node = graph[toModel]; ++ ++ if (node.parent === null) { ++ // No possible conversion, or this node is the source model. ++ continue; ++ } ++ ++ conversion[toModel] = wrapConversion$1(toModel, graph); ++ } ++ ++ return conversion; ++}; ++ ++const convert$2 = {}; ++const models$1 = Object.keys(conversions$1); ++ ++function wrapRaw$1(fn) { ++ const wrappedFn = function (...args) { ++ const arg0 = args[0]; ++ ++ if (arg0 === undefined || arg0 === null) { ++ return arg0; ++ } ++ ++ if (arg0.length > 1) { ++ args = arg0; ++ } ++ ++ return fn(args); ++ }; // Preserve .conversion property if there is one ++ ++ ++ if ('conversion' in fn) { ++ wrappedFn.conversion = fn.conversion; ++ } ++ ++ return wrappedFn; ++} ++ ++function wrapRounded$1(fn) { ++ const wrappedFn = function (...args) { ++ const arg0 = args[0]; ++ ++ if (arg0 === undefined || arg0 === null) { ++ return arg0; ++ } ++ ++ if (arg0.length > 1) { ++ args = arg0; ++ } ++ ++ const result = fn(args); // We're assuming the result is an array here. ++ // see notice in conversions.js; don't use box types ++ // in conversion functions. ++ ++ if (typeof result === 'object') { ++ for (let len = result.length, i = 0; i < len; i++) { ++ result[i] = Math.round(result[i]); ++ } ++ } ++ ++ return result; ++ }; // Preserve .conversion property if there is one ++ ++ ++ if ('conversion' in fn) { ++ wrappedFn.conversion = fn.conversion; ++ } ++ ++ return wrappedFn; ++} ++ ++models$1.forEach(fromModel => { ++ convert$2[fromModel] = {}; ++ Object.defineProperty(convert$2[fromModel], 'channels', { ++ value: conversions$1[fromModel].channels ++ }); ++ Object.defineProperty(convert$2[fromModel], 'labels', { ++ value: conversions$1[fromModel].labels ++ }); ++ const routes = route$1(fromModel); ++ const routeModels = Object.keys(routes); ++ routeModels.forEach(toModel => { ++ const fn = routes[toModel]; ++ convert$2[fromModel][toModel] = wrapRounded$1(fn); ++ convert$2[fromModel][toModel].raw = wrapRaw$1(fn); ++ }); ++}); ++var colorConvert$1 = convert$2; ++ ++var ansiStyles$1 = createCommonjsModule(function (module) { ++ ++ const wrapAnsi16 = (fn, offset) => (...args) => { ++ const code = fn(...args); ++ return `\u001B[${code + offset}m`; ++ }; ++ ++ const wrapAnsi256 = (fn, offset) => (...args) => { ++ const code = fn(...args); ++ return `\u001B[${38 + offset};5;${code}m`; ++ }; ++ ++ const wrapAnsi16m = (fn, offset) => (...args) => { ++ const rgb = fn(...args); ++ return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`; ++ }; ++ ++ const ansi2ansi = n => n; ++ ++ const rgb2rgb = (r, g, b) => [r, g, b]; ++ ++ const setLazyProperty = (object, property, get) => { ++ Object.defineProperty(object, property, { ++ get: () => { ++ const value = get(); ++ Object.defineProperty(object, property, { ++ value, ++ enumerable: true, ++ configurable: true ++ }); ++ return value; ++ }, ++ enumerable: true, ++ configurable: true ++ }); ++ }; ++ /** @type {typeof import('color-convert')} */ ++ ++ ++ let colorConvert; ++ ++ const makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => { ++ if (colorConvert === undefined) { ++ colorConvert = colorConvert$1; ++ } ++ ++ const offset = isBackground ? 10 : 0; ++ const styles = {}; ++ ++ for (const [sourceSpace, suite] of Object.entries(colorConvert)) { ++ const name = sourceSpace === 'ansi16' ? 'ansi' : sourceSpace; ++ ++ if (sourceSpace === targetSpace) { ++ styles[name] = wrap(identity, offset); ++ } else if (typeof suite === 'object') { ++ styles[name] = wrap(suite[targetSpace], offset); ++ } ++ } ++ ++ return styles; ++ }; ++ ++ function assembleStyles() { ++ const codes = new Map(); ++ const styles = { ++ modifier: { ++ reset: [0, 0], ++ // 21 isn't widely supported and 22 does the same thing ++ bold: [1, 22], ++ dim: [2, 22], ++ italic: [3, 23], ++ underline: [4, 24], ++ inverse: [7, 27], ++ hidden: [8, 28], ++ strikethrough: [9, 29] ++ }, ++ color: { ++ black: [30, 39], ++ red: [31, 39], ++ green: [32, 39], ++ yellow: [33, 39], ++ blue: [34, 39], ++ magenta: [35, 39], ++ cyan: [36, 39], ++ white: [37, 39], ++ // Bright color ++ blackBright: [90, 39], ++ redBright: [91, 39], ++ greenBright: [92, 39], ++ yellowBright: [93, 39], ++ blueBright: [94, 39], ++ magentaBright: [95, 39], ++ cyanBright: [96, 39], ++ whiteBright: [97, 39] ++ }, ++ bgColor: { ++ bgBlack: [40, 49], ++ bgRed: [41, 49], ++ bgGreen: [42, 49], ++ bgYellow: [43, 49], ++ bgBlue: [44, 49], ++ bgMagenta: [45, 49], ++ bgCyan: [46, 49], ++ bgWhite: [47, 49], ++ // Bright color ++ bgBlackBright: [100, 49], ++ bgRedBright: [101, 49], ++ bgGreenBright: [102, 49], ++ bgYellowBright: [103, 49], ++ bgBlueBright: [104, 49], ++ bgMagentaBright: [105, 49], ++ bgCyanBright: [106, 49], ++ bgWhiteBright: [107, 49] ++ } ++ }; // Alias bright black as gray (and grey) ++ ++ styles.color.gray = styles.color.blackBright; ++ styles.bgColor.bgGray = styles.bgColor.bgBlackBright; ++ styles.color.grey = styles.color.blackBright; ++ styles.bgColor.bgGrey = styles.bgColor.bgBlackBright; ++ ++ for (const [groupName, group] of Object.entries(styles)) { ++ for (const [styleName, style] of Object.entries(group)) { ++ styles[styleName] = { ++ open: `\u001B[${style[0]}m`, ++ close: `\u001B[${style[1]}m` ++ }; ++ group[styleName] = styles[styleName]; ++ codes.set(style[0], style[1]); ++ } ++ ++ Object.defineProperty(styles, groupName, { ++ value: group, ++ enumerable: false ++ }); ++ } ++ ++ Object.defineProperty(styles, 'codes', { ++ value: codes, ++ enumerable: false ++ }); ++ styles.color.close = '\u001B[39m'; ++ styles.bgColor.close = '\u001B[49m'; ++ setLazyProperty(styles.color, 'ansi', () => makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, false)); ++ setLazyProperty(styles.color, 'ansi256', () => makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, false)); ++ setLazyProperty(styles.color, 'ansi16m', () => makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, false)); ++ setLazyProperty(styles.bgColor, 'ansi', () => makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, true)); ++ setLazyProperty(styles.bgColor, 'ansi256', () => makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, true)); ++ setLazyProperty(styles.bgColor, 'ansi16m', () => makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, true)); ++ return styles; ++ } // Make the export immutable ++ ++ ++ Object.defineProperty(module, 'exports', { ++ enumerable: true, ++ get: assembleStyles ++ }); ++}); ++ ++var hasFlag$1 = (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); ++}; ++ ++const { ++ env: env$1 ++} = process; ++let forceColor$1; ++ ++if (hasFlag$1('no-color') || hasFlag$1('no-colors') || hasFlag$1('color=false') || hasFlag$1('color=never')) { ++ forceColor$1 = 0; ++} else if (hasFlag$1('color') || hasFlag$1('colors') || hasFlag$1('color=true') || hasFlag$1('color=always')) { ++ forceColor$1 = 1; ++} ++ ++if ('FORCE_COLOR' in env$1) { ++ if (env$1.FORCE_COLOR === 'true') { ++ forceColor$1 = 1; ++ } else if (env$1.FORCE_COLOR === 'false') { ++ forceColor$1 = 0; ++ } else { ++ forceColor$1 = env$1.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env$1.FORCE_COLOR, 10), 3); ++ } ++} ++ ++function translateLevel$1(level) { ++ if (level === 0) { ++ return false; ++ } ++ ++ return { ++ level, ++ hasBasic: true, ++ has256: level >= 2, ++ has16m: level >= 3 ++ }; ++} ++ ++function supportsColor$1(haveStream, streamIsTTY) { ++ if (forceColor$1 === 0) { ++ return 0; ++ } ++ ++ if (hasFlag$1('color=16m') || hasFlag$1('color=full') || hasFlag$1('color=truecolor')) { ++ return 3; ++ } ++ ++ if (hasFlag$1('color=256')) { ++ return 2; ++ } ++ ++ if (haveStream && !streamIsTTY && forceColor$1 === undefined) { ++ return 0; ++ } ++ ++ const min = forceColor$1 || 0; ++ ++ if (env$1.TERM === 'dumb') { ++ return min; ++ } ++ ++ if (process.platform === 'win32') { ++ // Windows 10 build 10586 is the first Windows release that supports 256 colors. ++ // Windows 10 build 14931 is the first release that supports 16m/TrueColor. ++ const osRelease = os.release().split('.'); ++ ++ if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) { ++ return Number(osRelease[2]) >= 14931 ? 3 : 2; ++ } ++ ++ return 1; ++ } ++ ++ if ('CI' in env$1) { ++ if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env$1) || env$1.CI_NAME === 'codeship') { ++ return 1; ++ } ++ ++ return min; ++ } ++ ++ if ('TEAMCITY_VERSION' in env$1) { ++ return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env$1.TEAMCITY_VERSION) ? 1 : 0; ++ } ++ ++ if ('GITHUB_ACTIONS' in env$1) { ++ return 1; ++ } ++ ++ if (env$1.COLORTERM === 'truecolor') { ++ return 3; ++ } ++ ++ if ('TERM_PROGRAM' in env$1) { ++ const version = parseInt((env$1.TERM_PROGRAM_VERSION || '').split('.')[0], 10); ++ ++ switch (env$1.TERM_PROGRAM) { ++ case 'iTerm.app': ++ return version >= 3 ? 3 : 2; ++ ++ case 'Apple_Terminal': ++ return 2; ++ // No default ++ } ++ } ++ ++ if (/-256(color)?$/i.test(env$1.TERM)) { ++ return 2; ++ } ++ ++ if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env$1.TERM)) { ++ return 1; ++ } ++ ++ if ('COLORTERM' in env$1) { ++ return 1; ++ } ++ ++ return min; ++} ++ ++function getSupportLevel$1(stream) { ++ const level = supportsColor$1(stream, stream && stream.isTTY); ++ return translateLevel$1(level); ++} ++ ++var supportsColor_1$1 = { ++ supportsColor: getSupportLevel$1, ++ stdout: translateLevel$1(supportsColor$1(true, tty.isatty(1))), ++ stderr: translateLevel$1(supportsColor$1(true, tty.isatty(2))) ++}; ++ ++const stringReplaceAll = (string, substring, replacer) => { ++ let index = string.indexOf(substring); ++ ++ if (index === -1) { ++ return string; ++ } ++ ++ const substringLength = substring.length; ++ let endIndex = 0; ++ let returnValue = ''; ++ ++ do { ++ returnValue += string.substr(endIndex, index - endIndex) + substring + replacer; ++ endIndex = index + substringLength; ++ index = string.indexOf(substring, endIndex); ++ } while (index !== -1); ++ ++ returnValue += string.substr(endIndex); ++ return returnValue; ++}; ++ ++const stringEncaseCRLFWithFirstIndex = (string, prefix, postfix, index) => { ++ let endIndex = 0; ++ let returnValue = ''; ++ ++ do { ++ const gotCR = string[index - 1] === '\r'; ++ returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? '\r\n' : '\n') + postfix; ++ endIndex = index + 1; ++ index = string.indexOf('\n', endIndex); ++ } while (index !== -1); ++ ++ returnValue += string.substr(endIndex); ++ return returnValue; ++}; ++ ++var util = { ++ stringReplaceAll, ++ stringEncaseCRLFWithFirstIndex ++}; ++ ++const TEMPLATE_REGEX$1 = /(?:\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi; ++const STYLE_REGEX$1 = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g; ++const STRING_REGEX$1 = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/; ++const ESCAPE_REGEX$1 = /\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.)|([^\\])/gi; ++const ESCAPES$1 = new Map([['n', '\n'], ['r', '\r'], ['t', '\t'], ['b', '\b'], ['f', '\f'], ['v', '\v'], ['0', '\0'], ['\\', '\\'], ['e', '\u001B'], ['a', '\u0007']]); ++ ++function unescape$1(c) { ++ const u = c[0] === 'u'; ++ const bracket = c[1] === '{'; ++ ++ if (u && !bracket && c.length === 5 || c[0] === 'x' && c.length === 3) { ++ return String.fromCharCode(parseInt(c.slice(1), 16)); ++ } ++ ++ if (u && bracket) { ++ return String.fromCodePoint(parseInt(c.slice(2, -1), 16)); ++ } ++ ++ return ESCAPES$1.get(c) || c; ++} ++ ++function parseArguments$1(name, arguments_) { ++ const results = []; ++ const chunks = arguments_.trim().split(/\s*,\s*/g); ++ let matches; ++ ++ for (const chunk of chunks) { ++ const number = Number(chunk); ++ ++ if (!Number.isNaN(number)) { ++ results.push(number); ++ } else if (matches = chunk.match(STRING_REGEX$1)) { ++ results.push(matches[2].replace(ESCAPE_REGEX$1, (m, escape, character) => escape ? unescape$1(escape) : character)); ++ } else { ++ throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`); ++ } ++ } ++ ++ return results; ++} ++ ++function parseStyle$1(style) { ++ STYLE_REGEX$1.lastIndex = 0; ++ const results = []; ++ let matches; ++ ++ while ((matches = STYLE_REGEX$1.exec(style)) !== null) { ++ const name = matches[1]; ++ ++ if (matches[2]) { ++ const args = parseArguments$1(name, matches[2]); ++ results.push([name].concat(args)); ++ } else { ++ results.push([name]); ++ } ++ } ++ ++ return results; ++} ++ ++function buildStyle$1(chalk, styles) { ++ const enabled = {}; ++ ++ for (const layer of styles) { ++ for (const style of layer.styles) { ++ enabled[style[0]] = layer.inverse ? null : style.slice(1); ++ } ++ } ++ ++ let current = chalk; ++ ++ for (const [styleName, styles] of Object.entries(enabled)) { ++ if (!Array.isArray(styles)) { ++ continue; ++ } ++ ++ if (!(styleName in current)) { ++ throw new Error(`Unknown Chalk style: ${styleName}`); ++ } ++ ++ current = styles.length > 0 ? current[styleName](...styles) : current[styleName]; ++ } ++ ++ return current; ++} ++ ++var templates$1 = (chalk, temporary) => { ++ const styles = []; ++ const chunks = []; ++ let chunk = []; // eslint-disable-next-line max-params ++ ++ temporary.replace(TEMPLATE_REGEX$1, (m, escapeCharacter, inverse, style, close, character) => { ++ if (escapeCharacter) { ++ chunk.push(unescape$1(escapeCharacter)); ++ } else if (style) { ++ const string = chunk.join(''); ++ chunk = []; ++ chunks.push(styles.length === 0 ? string : buildStyle$1(chalk, styles)(string)); ++ styles.push({ ++ inverse, ++ styles: parseStyle$1(style) ++ }); ++ } else if (close) { ++ if (styles.length === 0) { ++ throw new Error('Found extraneous } in Chalk template literal'); ++ } ++ ++ chunks.push(buildStyle$1(chalk, styles)(chunk.join(''))); ++ chunk = []; ++ styles.pop(); ++ } else { ++ chunk.push(character); ++ } ++ }); ++ chunks.push(chunk.join('')); ++ ++ if (styles.length > 0) { ++ const errMsg = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`; ++ throw new Error(errMsg); ++ } ++ ++ return chunks.join(''); ++}; ++ ++const { ++ stdout: stdoutColor, ++ stderr: stderrColor ++} = supportsColor_1$1; ++const { ++ stringReplaceAll: stringReplaceAll$1, ++ stringEncaseCRLFWithFirstIndex: stringEncaseCRLFWithFirstIndex$1 ++} = util; // `supportsColor.level` → `ansiStyles.color[name]` mapping ++ ++const levelMapping = ['ansi', 'ansi', 'ansi256', 'ansi16m']; ++const styles = Object.create(null); ++ ++const applyOptions = (object, options = {}) => { ++ if (options.level > 3 || options.level < 0) { ++ throw new Error('The `level` option should be an integer from 0 to 3'); ++ } // Detect level if not set manually ++ ++ ++ const colorLevel = stdoutColor ? stdoutColor.level : 0; ++ object.level = options.level === undefined ? colorLevel : options.level; ++}; ++ ++class ChalkClass { ++ constructor(options) { ++ return chalkFactory(options); ++ } ++ ++} ++ ++const chalkFactory = options => { ++ const chalk = {}; ++ applyOptions(chalk, options); ++ ++ chalk.template = (...arguments_) => chalkTag(chalk.template, ...arguments_); ++ ++ Object.setPrototypeOf(chalk, Chalk.prototype); ++ Object.setPrototypeOf(chalk.template, chalk); ++ ++ chalk.template.constructor = () => { ++ throw new Error('`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.'); ++ }; ++ ++ chalk.template.Instance = ChalkClass; ++ return chalk.template; ++}; ++ ++function Chalk(options) { ++ return chalkFactory(options); ++} ++ ++for (const [styleName, style] of Object.entries(ansiStyles$1)) { ++ styles[styleName] = { ++ get() { ++ const builder = createBuilder(this, createStyler(style.open, style.close, this._styler), this._isEmpty); ++ Object.defineProperty(this, styleName, { ++ value: builder ++ }); ++ return builder; ++ } ++ ++ }; ++} ++ ++styles.visible = { ++ get() { ++ const builder = createBuilder(this, this._styler, true); ++ Object.defineProperty(this, 'visible', { ++ value: builder ++ }); ++ return builder; ++ } ++ ++}; ++const usedModels = ['rgb', 'hex', 'keyword', 'hsl', 'hsv', 'hwb', 'ansi', 'ansi256']; ++ ++for (const model of usedModels) { ++ styles[model] = { ++ get() { ++ const { ++ level ++ } = this; ++ return function (...arguments_) { ++ const styler = createStyler(ansiStyles$1.color[levelMapping[level]][model](...arguments_), ansiStyles$1.color.close, this._styler); ++ return createBuilder(this, styler, this._isEmpty); ++ }; ++ } ++ ++ }; ++} ++ ++for (const model of usedModels) { ++ const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1); ++ styles[bgModel] = { ++ get() { ++ const { ++ level ++ } = this; ++ return function (...arguments_) { ++ const styler = createStyler(ansiStyles$1.bgColor[levelMapping[level]][model](...arguments_), ansiStyles$1.bgColor.close, this._styler); ++ return createBuilder(this, styler, this._isEmpty); ++ }; ++ } ++ ++ }; ++} ++ ++const proto = Object.defineProperties(() => {}, Object.assign({}, styles, { ++ level: { ++ enumerable: true, ++ ++ get() { ++ return this._generator.level; ++ }, ++ ++ set(level) { ++ this._generator.level = level; ++ } ++ ++ } ++})); ++ ++const createStyler = (open, close, parent) => { ++ let openAll; ++ let closeAll; ++ ++ if (parent === undefined) { ++ openAll = open; ++ closeAll = close; ++ } else { ++ openAll = parent.openAll + open; ++ closeAll = close + parent.closeAll; ++ } ++ ++ return { ++ open, ++ close, ++ openAll, ++ closeAll, ++ parent ++ }; ++}; ++ ++const createBuilder = (self, _styler, _isEmpty) => { ++ const builder = (...arguments_) => { ++ // Single argument is hot path, implicit coercion is faster than anything ++ // eslint-disable-next-line no-implicit-coercion ++ return applyStyle(builder, arguments_.length === 1 ? '' + arguments_[0] : arguments_.join(' ')); ++ }; // `__proto__` is used because we must return a function, but there is ++ // no way to create a function with a different prototype ++ ++ ++ builder.__proto__ = proto; // eslint-disable-line no-proto ++ ++ builder._generator = self; ++ builder._styler = _styler; ++ builder._isEmpty = _isEmpty; ++ return builder; ++}; ++ ++const applyStyle = (self, string) => { ++ if (self.level <= 0 || !string) { ++ return self._isEmpty ? '' : string; ++ } ++ ++ let styler = self._styler; ++ ++ if (styler === undefined) { ++ return string; ++ } ++ ++ const { ++ openAll, ++ closeAll ++ } = styler; ++ ++ if (string.indexOf('\u001B') !== -1) { ++ while (styler !== undefined) { ++ // Replace any instances already present with a re-opening code ++ // otherwise only the part of the string until said closing code ++ // will be colored, and the rest will simply be 'plain'. ++ string = stringReplaceAll$1(string, styler.close, styler.open); ++ styler = styler.parent; ++ } ++ } // We can move both next actions out of loop, because remaining actions in loop won't have ++ // any/visible effect on parts we add here. Close the styling before a linebreak and reopen ++ // after next line to fix a bleed issue on macOS: https://github.com/chalk/chalk/pull/92 ++ ++ ++ const lfIndex = string.indexOf('\n'); ++ ++ if (lfIndex !== -1) { ++ string = stringEncaseCRLFWithFirstIndex$1(string, closeAll, openAll, lfIndex); ++ } ++ ++ return openAll + string + closeAll; ++}; ++ ++let template; ++ ++const chalkTag = (chalk, ...strings) => { ++ const [firstString] = strings; ++ ++ if (!Array.isArray(firstString)) { ++ // If chalk() was called by itself or with a string, ++ // return the string itself as a string. ++ return strings.join(' '); ++ } ++ ++ const arguments_ = strings.slice(1); ++ const parts = [firstString.raw[0]]; ++ ++ for (let i = 1; i < firstString.length; i++) { ++ parts.push(String(arguments_[i - 1]).replace(/[{}\\]/g, '\\$&'), String(firstString.raw[i])); ++ } ++ ++ if (template === undefined) { ++ template = templates$1; ++ } ++ ++ return template(chalk, parts.join('')); ++}; ++ ++Object.defineProperties(Chalk.prototype, styles); ++const chalk$1 = Chalk(); // eslint-disable-line new-cap ++ ++chalk$1.supportsColor = stdoutColor; ++chalk$1.stderr = Chalk({ ++ level: stderrColor ? stderrColor.level : 0 ++}); // eslint-disable-line new-cap ++ ++chalk$1.stderr.supportsColor = stderrColor; // For TypeScript ++ ++chalk$1.Level = { ++ None: 0, ++ Basic: 1, ++ Ansi256: 2, ++ TrueColor: 3, ++ 0: 'None', ++ 1: 'Basic', ++ 2: 'Ansi256', ++ 3: 'TrueColor' ++}; ++var source = chalk$1; ++ ++const cliDescriptor = { ++ key: key => key.length === 1 ? `-${key}` : `--${key}`, ++ value: value => lib.apiDescriptor.value(value), ++ pair: ({ ++ key, ++ value ++ }) => value === false ? `--no-${key}` : value === true ? cliDescriptor.key(key) : value === "" ? `${cliDescriptor.key(key)} without an argument` : `${cliDescriptor.key(key)}=${value}` ++}; ++ ++class FlagSchema extends lib.ChoiceSchema { ++ constructor({ ++ name, ++ flags ++ }) { ++ super({ ++ name, ++ choices: flags ++ }); ++ this._flags = flags.slice().sort(); ++ } ++ ++ preprocess(value, utils) { ++ if (typeof value === "string" && value.length !== 0 && !this._flags.includes(value)) { ++ const suggestion = this._flags.find(flag => leven_1$1(flag, value) < 3); ++ ++ if (suggestion) { ++ utils.logger.warn([`Unknown flag ${source.yellow(utils.descriptor.value(value))},`, `did you mean ${source.blue(utils.descriptor.value(suggestion))}?`].join(" ")); ++ return suggestion; ++ } ++ } ++ ++ return value; ++ } ++ ++ expected() { ++ return "a flag"; ++ } ++ ++} ++ ++let hasDeprecationWarned; ++ ++function normalizeOptions(options, optionInfos, { ++ logger, ++ isCLI = false, ++ passThrough = false ++} = {}) { ++ const unknown = !passThrough ? lib.levenUnknownHandler : Array.isArray(passThrough) ? (key, value) => !passThrough.includes(key) ? undefined : { ++ [key]: value ++ } : (key, value) => ({ ++ [key]: value ++ }); ++ const descriptor = isCLI ? cliDescriptor : lib.apiDescriptor; ++ const schemas = optionInfosToSchemas(optionInfos, { ++ isCLI ++ }); ++ const normalizer = new lib.Normalizer(schemas, { ++ logger, ++ unknown, ++ descriptor ++ }); ++ const shouldSuppressDuplicateDeprecationWarnings = logger !== false; ++ ++ if (shouldSuppressDuplicateDeprecationWarnings && hasDeprecationWarned) { ++ normalizer._hasDeprecationWarned = hasDeprecationWarned; ++ } ++ ++ const normalized = normalizer.normalize(options); ++ ++ if (shouldSuppressDuplicateDeprecationWarnings) { ++ hasDeprecationWarned = normalizer._hasDeprecationWarned; ++ } ++ ++ return normalized; ++} ++ ++function optionInfosToSchemas(optionInfos, { ++ isCLI ++}) { ++ const schemas = []; ++ ++ if (isCLI) { ++ schemas.push(lib.AnySchema.create({ ++ name: "_" ++ })); ++ } ++ ++ for (const optionInfo of optionInfos) { ++ schemas.push(optionInfoToSchema(optionInfo, { ++ isCLI, ++ optionInfos ++ })); ++ ++ if (optionInfo.alias && isCLI) { ++ schemas.push(lib.AliasSchema.create({ ++ name: optionInfo.alias, ++ sourceName: optionInfo.name ++ })); ++ } ++ } ++ ++ return schemas; ++} ++ ++function optionInfoToSchema(optionInfo, { ++ isCLI, ++ optionInfos ++}) { ++ let SchemaConstructor; ++ const parameters = { ++ name: optionInfo.name ++ }; ++ const handlers = {}; ++ ++ switch (optionInfo.type) { ++ case "int": ++ SchemaConstructor = lib.IntegerSchema; ++ ++ if (isCLI) { ++ parameters.preprocess = value => Number(value); ++ } ++ ++ break; ++ ++ case "string": ++ SchemaConstructor = lib.StringSchema; ++ break; ++ ++ case "choice": ++ SchemaConstructor = lib.ChoiceSchema; ++ parameters.choices = optionInfo.choices.map(choiceInfo => typeof choiceInfo === "object" && choiceInfo.redirect ? Object.assign({}, choiceInfo, { ++ redirect: { ++ to: { ++ key: optionInfo.name, ++ value: choiceInfo.redirect ++ } ++ } ++ }) : choiceInfo); ++ break; ++ ++ case "boolean": ++ SchemaConstructor = lib.BooleanSchema; ++ break; ++ ++ case "flag": ++ SchemaConstructor = FlagSchema; ++ parameters.flags = optionInfos.map(optionInfo => [].concat(optionInfo.alias || [], optionInfo.description ? optionInfo.name : [], optionInfo.oppositeDescription ? `no-${optionInfo.name}` : [])).reduce((a, b) => a.concat(b), []); ++ break; ++ ++ case "path": ++ SchemaConstructor = lib.StringSchema; ++ break; ++ ++ default: ++ throw new Error(`Unexpected type ${optionInfo.type}`); ++ } ++ ++ if (optionInfo.exception) { ++ parameters.validate = (value, schema, utils) => { ++ return optionInfo.exception(value) || schema.validate(value, utils); ++ }; ++ } else { ++ parameters.validate = (value, schema, utils) => { ++ return value === undefined || schema.validate(value, utils); ++ }; ++ } ++ ++ if (optionInfo.redirect) { ++ handlers.redirect = value => !value ? undefined : { ++ to: { ++ key: optionInfo.redirect.option, ++ value: optionInfo.redirect.value ++ } ++ }; ++ } ++ ++ if (optionInfo.deprecated) { ++ handlers.deprecated = true; ++ } // allow CLI overriding, e.g., prettier package.json --tab-width 1 --tab-width 2 ++ ++ ++ if (isCLI && !optionInfo.array) { ++ const originalPreprocess = parameters.preprocess || (x => x); ++ ++ parameters.preprocess = (value, schema, utils) => schema.preprocess(originalPreprocess(Array.isArray(value) ? value[value.length - 1] : value), utils); ++ } ++ ++ return optionInfo.array ? lib.ArraySchema.create(Object.assign({}, isCLI ? { ++ preprocess: v => [].concat(v) ++ } : {}, {}, handlers, { ++ valueSchema: SchemaConstructor.create(parameters) ++ })) : SchemaConstructor.create(Object.assign({}, parameters, {}, handlers)); ++} ++ ++function normalizeApiOptions(options, optionInfos, opts) { ++ return normalizeOptions(options, optionInfos, opts); ++} ++ ++function normalizeCliOptions(options, optionInfos, opts) { ++ return normalizeOptions(options, optionInfos, Object.assign({ ++ isCLI: true ++ }, opts)); ++} ++ ++var optionsNormalizer = { ++ normalizeApiOptions, ++ normalizeCliOptions ++}; ++ ++var getLast = arr => arr[arr.length - 1]; ++ ++function locStart(node, opts) { ++ opts = opts || {}; // Handle nodes with decorators. They should start at the first decorator ++ ++ if (!opts.ignoreDecorators && node.declaration && node.declaration.decorators && node.declaration.decorators.length > 0) { ++ return locStart(node.declaration.decorators[0]); ++ } ++ ++ if (!opts.ignoreDecorators && node.decorators && node.decorators.length > 0) { ++ return locStart(node.decorators[0]); ++ } ++ ++ if (node.__location) { ++ return node.__location.startOffset; ++ } ++ ++ if (node.range) { ++ return node.range[0]; ++ } ++ ++ if (typeof node.start === "number") { ++ return node.start; ++ } ++ ++ if (node.loc) { ++ return node.loc.start; ++ } ++ ++ return null; ++} ++ ++function locEnd(node) { ++ const endNode = node.nodes && getLast(node.nodes); ++ ++ if (endNode && node.source && !node.source.end) { ++ node = endNode; ++ } ++ ++ if (node.__location) { ++ return node.__location.endOffset; ++ } ++ ++ const loc = node.range ? node.range[1] : typeof node.end === "number" ? node.end : null; ++ ++ if (node.typeAnnotation) { ++ return Math.max(loc, locEnd(node.typeAnnotation)); ++ } ++ ++ if (node.loc && !loc) { ++ return node.loc.end; ++ } ++ ++ return loc; ++} ++ ++function composeLoc(startNode, endNodeOrLength = startNode) { ++ const length = typeof endNodeOrLength === "number" ? endNodeOrLength : -1; ++ const start = locStart(startNode); ++ const end = length !== -1 ? start + length : locEnd(endNodeOrLength); ++ const startLoc = startNode.loc.start; ++ return { ++ start, ++ end, ++ range: [start, end], ++ loc: { ++ start: startLoc, ++ end: length !== -1 ? { ++ line: startLoc.line, ++ column: startLoc.column + length ++ } : endNodeOrLength.loc.end ++ } ++ }; ++} ++ ++var loc = { ++ locStart, ++ locEnd, ++ composeLoc ++}; ++ ++var jsTokens = createCommonjsModule(function (module, exports) { ++ // Copyright 2014, 2015, 2016, 2017, 2018 Simon Lydell ++ // License: MIT. (See LICENSE.) ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); // This regex comes from regex.coffee, and is inserted here by generate-index.js ++ // (run `npm run build`). ++ ++ exports.default = /((['"])(?:(?!\2|\\).|\\(?:\r\n|[\s\S]))*(\2)?|`(?:[^`\\$]|\\[\s\S]|\$(?!\{)|\$\{(?:[^{}]|\{[^}]*\}?)*\}?)*(`)?)|(\/\/.*)|(\/\*(?:[^*]|\*(?!\/))*(\*\/)?)|(\/(?!\*)(?:\[(?:(?![\]\\]).|\\.)*\]|(?![\/\]\\]).|\\.)+\/(?:(?!\s*(?:\b|[\u0080-\uFFFF$\\'"~({]|[+\-!](?!=)|\.?\d))|[gmiyus]{1,6}\b(?![\u0080-\uFFFF$\\]|\s*(?:[+\-*%&|^<>!=?({]|\/(?![\/*])))))|(0[xX][\da-fA-F]+|0[oO][0-7]+|0[bB][01]+|(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?)|((?!\d)(?:(?!\s)[$\w\u0080-\uFFFF]|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+)|(--|\+\+|&&|\|\||=>|\.{3}|(?:[+\-\/%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2})=?|[?~.,:;[\](){}])|(\s+)|(^$|[\s\S])/g; ++ ++ exports.matchToToken = function (match) { ++ var token = { ++ type: "invalid", ++ value: match[0], ++ closed: undefined ++ }; ++ if (match[1]) token.type = "string", token.closed = !!(match[3] || match[4]);else if (match[5]) token.type = "comment";else if (match[6]) token.type = "comment", token.closed = !!match[7];else if (match[8]) token.type = "regex";else if (match[9]) token.type = "number";else if (match[10]) token.type = "name";else if (match[11]) token.type = "punctuator";else if (match[12]) token.type = "whitespace"; ++ return token; ++ }; ++}); ++unwrapExports(jsTokens); ++var jsTokens_1 = jsTokens.matchToToken; ++ ++var ast = createCommonjsModule(function (module) { ++ /* ++ Copyright (C) 2013 Yusuke Suzuki ++ ++ 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. ++ ++ 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 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. ++ */ ++ (function () { ++ ++ function isExpression(node) { ++ if (node == null) { ++ return false; ++ } ++ ++ switch (node.type) { ++ case 'ArrayExpression': ++ case 'AssignmentExpression': ++ case 'BinaryExpression': ++ case 'CallExpression': ++ case 'ConditionalExpression': ++ case 'FunctionExpression': ++ case 'Identifier': ++ case 'Literal': ++ case 'LogicalExpression': ++ case 'MemberExpression': ++ case 'NewExpression': ++ case 'ObjectExpression': ++ case 'SequenceExpression': ++ case 'ThisExpression': ++ case 'UnaryExpression': ++ case 'UpdateExpression': ++ return true; ++ } ++ ++ return false; ++ } ++ ++ function isIterationStatement(node) { ++ if (node == null) { ++ return false; ++ } ++ ++ switch (node.type) { ++ case 'DoWhileStatement': ++ case 'ForInStatement': ++ case 'ForStatement': ++ case 'WhileStatement': ++ return true; ++ } ++ ++ return false; ++ } ++ ++ function isStatement(node) { ++ if (node == null) { ++ return false; ++ } ++ ++ switch (node.type) { ++ case 'BlockStatement': ++ case 'BreakStatement': ++ case 'ContinueStatement': ++ case 'DebuggerStatement': ++ case 'DoWhileStatement': ++ case 'EmptyStatement': ++ case 'ExpressionStatement': ++ case 'ForInStatement': ++ case 'ForStatement': ++ case 'IfStatement': ++ case 'LabeledStatement': ++ case 'ReturnStatement': ++ case 'SwitchStatement': ++ case 'ThrowStatement': ++ case 'TryStatement': ++ case 'VariableDeclaration': ++ case 'WhileStatement': ++ case 'WithStatement': ++ return true; ++ } ++ ++ return false; ++ } ++ ++ function isSourceElement(node) { ++ return isStatement(node) || node != null && node.type === 'FunctionDeclaration'; ++ } ++ ++ function trailingStatement(node) { ++ switch (node.type) { ++ case 'IfStatement': ++ if (node.alternate != null) { ++ return node.alternate; ++ } ++ ++ return node.consequent; ++ ++ case 'LabeledStatement': ++ case 'ForStatement': ++ case 'ForInStatement': ++ case 'WhileStatement': ++ case 'WithStatement': ++ return node.body; ++ } ++ ++ return null; ++ } ++ ++ function isProblematicIfStatement(node) { ++ var current; ++ ++ if (node.type !== 'IfStatement') { ++ return false; ++ } ++ ++ if (node.alternate == null) { ++ return false; ++ } ++ ++ current = node.consequent; ++ ++ do { ++ if (current.type === 'IfStatement') { ++ if (current.alternate == null) { ++ return true; ++ } ++ } ++ ++ current = trailingStatement(current); ++ } while (current); ++ ++ return false; ++ } ++ ++ module.exports = { ++ isExpression: isExpression, ++ isStatement: isStatement, ++ isIterationStatement: isIterationStatement, ++ isSourceElement: isSourceElement, ++ isProblematicIfStatement: isProblematicIfStatement, ++ trailingStatement: trailingStatement ++ }; ++ })(); ++ /* vim: set sw=4 ts=4 et tw=80 : */ ++ ++}); ++var ast_1 = ast.isExpression; ++var ast_2 = ast.isStatement; ++var ast_3 = ast.isIterationStatement; ++var ast_4 = ast.isSourceElement; ++var ast_5 = ast.isProblematicIfStatement; ++var ast_6 = ast.trailingStatement; ++ ++var code = createCommonjsModule(function (module) { ++ /* ++ Copyright (C) 2013-2014 Yusuke Suzuki ++ Copyright (C) 2014 Ivan Nikulin ++ ++ 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. ++ ++ 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 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. ++ */ ++ (function () { ++ ++ var ES6Regex, ES5Regex, NON_ASCII_WHITESPACES, IDENTIFIER_START, IDENTIFIER_PART, ch; // See `tools/generate-identifier-regex.js`. ++ ++ ES5Regex = { ++ // ECMAScript 5.1/Unicode v9.0.0 NonAsciiIdentifierStart: ++ NonAsciiIdentifierStart: /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B4\u08B6-\u08BD\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]/, ++ // ECMAScript 5.1/Unicode v9.0.0 NonAsciiIdentifierPart: ++ NonAsciiIdentifierPart: /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B4\u08B6-\u08BD\u08D4-\u08E1\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C80-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D54-\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C88\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFB-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]/ ++ }; ++ ES6Regex = { ++ // ECMAScript 6/Unicode v9.0.0 NonAsciiIdentifierStart: ++ NonAsciiIdentifierStart: /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B4\u08B6-\u08BD\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDF00-\uDF19]|\uD806[\uDCA0-\uDCDF\uDCFF\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC72-\uDC8F]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F\uDFE0]|\uD821[\uDC00-\uDFEC]|\uD822[\uDC00-\uDEF2]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDC00-\uDCC4\uDD00-\uDD43]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]/, ++ // ECMAScript 6/Unicode v9.0.0 NonAsciiIdentifierPart: ++ NonAsciiIdentifierPart: /[\xAA\xB5\xB7\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B4\u08B6-\u08BD\u08D4-\u08E1\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C80-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D54-\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1369-\u1371\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C88\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFB-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDCA-\uDDCC\uDDD0-\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE37\uDE3E\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC00-\uDC4A\uDC50-\uDC59\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDDD8-\uDDDD\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB7\uDEC0-\uDEC9\uDF00-\uDF19\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDCA0-\uDCE9\uDCFF\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC36\uDC38-\uDC40\uDC50-\uDC59\uDC72-\uDC8F\uDC92-\uDCA7\uDCA9-\uDCB6]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F\uDFE0]|\uD821[\uDC00-\uDFEC]|\uD822[\uDC00-\uDEF2]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6\uDD00-\uDD4A\uDD50-\uDD59]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF]/ ++ }; ++ ++ function isDecimalDigit(ch) { ++ return 0x30 <= ch && ch <= 0x39; // 0..9 ++ } ++ ++ function isHexDigit(ch) { ++ return 0x30 <= ch && ch <= 0x39 || // 0..9 ++ 0x61 <= ch && ch <= 0x66 || // a..f ++ 0x41 <= ch && ch <= 0x46; // A..F ++ } ++ ++ function isOctalDigit(ch) { ++ return ch >= 0x30 && ch <= 0x37; // 0..7 ++ } // 7.2 White Space ++ ++ ++ NON_ASCII_WHITESPACES = [0x1680, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x202F, 0x205F, 0x3000, 0xFEFF]; ++ ++ function isWhiteSpace(ch) { ++ return ch === 0x20 || ch === 0x09 || ch === 0x0B || ch === 0x0C || ch === 0xA0 || ch >= 0x1680 && NON_ASCII_WHITESPACES.indexOf(ch) >= 0; ++ } // 7.3 Line Terminators ++ ++ ++ function isLineTerminator(ch) { ++ return ch === 0x0A || ch === 0x0D || ch === 0x2028 || ch === 0x2029; ++ } // 7.6 Identifier Names and Identifiers ++ ++ ++ function fromCodePoint(cp) { ++ if (cp <= 0xFFFF) { ++ return String.fromCharCode(cp); ++ } ++ ++ var cu1 = String.fromCharCode(Math.floor((cp - 0x10000) / 0x400) + 0xD800); ++ var cu2 = String.fromCharCode((cp - 0x10000) % 0x400 + 0xDC00); ++ return cu1 + cu2; ++ } ++ ++ IDENTIFIER_START = new Array(0x80); ++ ++ for (ch = 0; ch < 0x80; ++ch) { ++ IDENTIFIER_START[ch] = ch >= 0x61 && ch <= 0x7A || // a..z ++ ch >= 0x41 && ch <= 0x5A || // A..Z ++ ch === 0x24 || ch === 0x5F; // $ (dollar) and _ (underscore) ++ } ++ ++ IDENTIFIER_PART = new Array(0x80); ++ ++ for (ch = 0; ch < 0x80; ++ch) { ++ IDENTIFIER_PART[ch] = ch >= 0x61 && ch <= 0x7A || // a..z ++ ch >= 0x41 && ch <= 0x5A || // A..Z ++ ch >= 0x30 && ch <= 0x39 || // 0..9 ++ ch === 0x24 || ch === 0x5F; // $ (dollar) and _ (underscore) ++ } ++ ++ function isIdentifierStartES5(ch) { ++ return ch < 0x80 ? IDENTIFIER_START[ch] : ES5Regex.NonAsciiIdentifierStart.test(fromCodePoint(ch)); ++ } ++ ++ function isIdentifierPartES5(ch) { ++ return ch < 0x80 ? IDENTIFIER_PART[ch] : ES5Regex.NonAsciiIdentifierPart.test(fromCodePoint(ch)); ++ } ++ ++ function isIdentifierStartES6(ch) { ++ return ch < 0x80 ? IDENTIFIER_START[ch] : ES6Regex.NonAsciiIdentifierStart.test(fromCodePoint(ch)); ++ } ++ ++ function isIdentifierPartES6(ch) { ++ return ch < 0x80 ? IDENTIFIER_PART[ch] : ES6Regex.NonAsciiIdentifierPart.test(fromCodePoint(ch)); ++ } ++ ++ module.exports = { ++ isDecimalDigit: isDecimalDigit, ++ isHexDigit: isHexDigit, ++ isOctalDigit: isOctalDigit, ++ isWhiteSpace: isWhiteSpace, ++ isLineTerminator: isLineTerminator, ++ isIdentifierStartES5: isIdentifierStartES5, ++ isIdentifierPartES5: isIdentifierPartES5, ++ isIdentifierStartES6: isIdentifierStartES6, ++ isIdentifierPartES6: isIdentifierPartES6 ++ }; ++ })(); ++ /* vim: set sw=4 ts=4 et tw=80 : */ ++ ++}); ++var code_1 = code.isDecimalDigit; ++var code_2 = code.isHexDigit; ++var code_3 = code.isOctalDigit; ++var code_4 = code.isWhiteSpace; ++var code_5 = code.isLineTerminator; ++var code_6 = code.isIdentifierStartES5; ++var code_7 = code.isIdentifierPartES5; ++var code_8 = code.isIdentifierStartES6; ++var code_9 = code.isIdentifierPartES6; ++ ++var keyword = createCommonjsModule(function (module) { ++ /* ++ Copyright (C) 2013 Yusuke Suzuki ++ ++ 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. ++ ++ 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 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. ++ */ ++ (function () { ++ ++ var code$1 = code; ++ ++ function isStrictModeReservedWordES6(id) { ++ switch (id) { ++ case 'implements': ++ case 'interface': ++ case 'package': ++ case 'private': ++ case 'protected': ++ case 'public': ++ case 'static': ++ case 'let': ++ return true; ++ ++ default: ++ return false; ++ } ++ } ++ ++ function isKeywordES5(id, strict) { ++ // yield should not be treated as keyword under non-strict mode. ++ if (!strict && id === 'yield') { ++ return false; ++ } ++ ++ return isKeywordES6(id, strict); ++ } ++ ++ function isKeywordES6(id, strict) { ++ if (strict && isStrictModeReservedWordES6(id)) { ++ return true; ++ } ++ ++ switch (id.length) { ++ case 2: ++ return id === 'if' || id === 'in' || id === 'do'; ++ ++ case 3: ++ return id === 'var' || id === 'for' || id === 'new' || id === 'try'; ++ ++ case 4: ++ return id === 'this' || id === 'else' || id === 'case' || id === 'void' || id === 'with' || id === 'enum'; ++ ++ case 5: ++ return id === 'while' || id === 'break' || id === 'catch' || id === 'throw' || id === 'const' || id === 'yield' || id === 'class' || id === 'super'; ++ ++ case 6: ++ return id === 'return' || id === 'typeof' || id === 'delete' || id === 'switch' || id === 'export' || id === 'import'; ++ ++ case 7: ++ return id === 'default' || id === 'finally' || id === 'extends'; ++ ++ case 8: ++ return id === 'function' || id === 'continue' || id === 'debugger'; ++ ++ case 10: ++ return id === 'instanceof'; ++ ++ default: ++ return false; ++ } ++ } ++ ++ function isReservedWordES5(id, strict) { ++ return id === 'null' || id === 'true' || id === 'false' || isKeywordES5(id, strict); ++ } ++ ++ function isReservedWordES6(id, strict) { ++ return id === 'null' || id === 'true' || id === 'false' || isKeywordES6(id, strict); ++ } ++ ++ function isRestrictedWord(id) { ++ return id === 'eval' || id === 'arguments'; ++ } ++ ++ function isIdentifierNameES5(id) { ++ var i, iz, ch; ++ ++ if (id.length === 0) { ++ return false; ++ } ++ ++ ch = id.charCodeAt(0); ++ ++ if (!code$1.isIdentifierStartES5(ch)) { ++ return false; ++ } ++ ++ for (i = 1, iz = id.length; i < iz; ++i) { ++ ch = id.charCodeAt(i); ++ ++ if (!code$1.isIdentifierPartES5(ch)) { ++ return false; ++ } ++ } ++ ++ return true; ++ } ++ ++ function decodeUtf16(lead, trail) { ++ return (lead - 0xD800) * 0x400 + (trail - 0xDC00) + 0x10000; ++ } ++ ++ function isIdentifierNameES6(id) { ++ var i, iz, ch, lowCh, check; ++ ++ if (id.length === 0) { ++ return false; ++ } ++ ++ check = code$1.isIdentifierStartES6; ++ ++ for (i = 0, iz = id.length; i < iz; ++i) { ++ ch = id.charCodeAt(i); ++ ++ if (0xD800 <= ch && ch <= 0xDBFF) { ++ ++i; ++ ++ if (i >= iz) { ++ return false; ++ } ++ ++ lowCh = id.charCodeAt(i); ++ ++ if (!(0xDC00 <= lowCh && lowCh <= 0xDFFF)) { ++ return false; ++ } ++ ++ ch = decodeUtf16(ch, lowCh); ++ } ++ ++ if (!check(ch)) { ++ return false; ++ } ++ ++ check = code$1.isIdentifierPartES6; ++ } ++ ++ return true; ++ } ++ ++ function isIdentifierES5(id, strict) { ++ return isIdentifierNameES5(id) && !isReservedWordES5(id, strict); ++ } ++ ++ function isIdentifierES6(id, strict) { ++ return isIdentifierNameES6(id) && !isReservedWordES6(id, strict); ++ } ++ ++ module.exports = { ++ isKeywordES5: isKeywordES5, ++ isKeywordES6: isKeywordES6, ++ isReservedWordES5: isReservedWordES5, ++ isReservedWordES6: isReservedWordES6, ++ isRestrictedWord: isRestrictedWord, ++ isIdentifierNameES5: isIdentifierNameES5, ++ isIdentifierNameES6: isIdentifierNameES6, ++ isIdentifierES5: isIdentifierES5, ++ isIdentifierES6: isIdentifierES6 ++ }; ++ })(); ++ /* vim: set sw=4 ts=4 et tw=80 : */ ++ ++}); ++var keyword_1 = keyword.isKeywordES5; ++var keyword_2 = keyword.isKeywordES6; ++var keyword_3 = keyword.isReservedWordES5; ++var keyword_4 = keyword.isReservedWordES6; ++var keyword_5 = keyword.isRestrictedWord; ++var keyword_6 = keyword.isIdentifierNameES5; ++var keyword_7 = keyword.isIdentifierNameES6; ++var keyword_8 = keyword.isIdentifierES5; ++var keyword_9 = keyword.isIdentifierES6; ++ ++var utils$1 = createCommonjsModule(function (module, exports) { ++ /* ++ Copyright (C) 2013 Yusuke Suzuki ++ ++ 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. ++ ++ 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 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. ++ */ ++ (function () { ++ ++ exports.ast = ast; ++ exports.code = code; ++ exports.keyword = keyword; ++ })(); ++ /* vim: set sw=4 ts=4 et tw=80 : */ ++ ++}); ++var utils_1$1 = utils$1.ast; ++var utils_2$1 = utils$1.code; ++var utils_3$1 = utils$1.keyword; ++ ++var matchOperatorsRe$1 = /[|\\{}()[\]^$+*?.]/g; ++ ++var escapeStringRegexp$1 = function (str) { ++ if (typeof str !== 'string') { ++ throw new TypeError('Expected a string'); ++ } ++ ++ return str.replace(matchOperatorsRe$1, '\\$&'); ++}; ++ ++var colorName$2 = { ++ "aliceblue": [240, 248, 255], ++ "antiquewhite": [250, 235, 215], ++ "aqua": [0, 255, 255], ++ "aquamarine": [127, 255, 212], ++ "azure": [240, 255, 255], ++ "beige": [245, 245, 220], ++ "bisque": [255, 228, 196], ++ "black": [0, 0, 0], ++ "blanchedalmond": [255, 235, 205], ++ "blue": [0, 0, 255], ++ "blueviolet": [138, 43, 226], ++ "brown": [165, 42, 42], ++ "burlywood": [222, 184, 135], ++ "cadetblue": [95, 158, 160], ++ "chartreuse": [127, 255, 0], ++ "chocolate": [210, 105, 30], ++ "coral": [255, 127, 80], ++ "cornflowerblue": [100, 149, 237], ++ "cornsilk": [255, 248, 220], ++ "crimson": [220, 20, 60], ++ "cyan": [0, 255, 255], ++ "darkblue": [0, 0, 139], ++ "darkcyan": [0, 139, 139], ++ "darkgoldenrod": [184, 134, 11], ++ "darkgray": [169, 169, 169], ++ "darkgreen": [0, 100, 0], ++ "darkgrey": [169, 169, 169], ++ "darkkhaki": [189, 183, 107], ++ "darkmagenta": [139, 0, 139], ++ "darkolivegreen": [85, 107, 47], ++ "darkorange": [255, 140, 0], ++ "darkorchid": [153, 50, 204], ++ "darkred": [139, 0, 0], ++ "darksalmon": [233, 150, 122], ++ "darkseagreen": [143, 188, 143], ++ "darkslateblue": [72, 61, 139], ++ "darkslategray": [47, 79, 79], ++ "darkslategrey": [47, 79, 79], ++ "darkturquoise": [0, 206, 209], ++ "darkviolet": [148, 0, 211], ++ "deeppink": [255, 20, 147], ++ "deepskyblue": [0, 191, 255], ++ "dimgray": [105, 105, 105], ++ "dimgrey": [105, 105, 105], ++ "dodgerblue": [30, 144, 255], ++ "firebrick": [178, 34, 34], ++ "floralwhite": [255, 250, 240], ++ "forestgreen": [34, 139, 34], ++ "fuchsia": [255, 0, 255], ++ "gainsboro": [220, 220, 220], ++ "ghostwhite": [248, 248, 255], ++ "gold": [255, 215, 0], ++ "goldenrod": [218, 165, 32], ++ "gray": [128, 128, 128], ++ "green": [0, 128, 0], ++ "greenyellow": [173, 255, 47], ++ "grey": [128, 128, 128], ++ "honeydew": [240, 255, 240], ++ "hotpink": [255, 105, 180], ++ "indianred": [205, 92, 92], ++ "indigo": [75, 0, 130], ++ "ivory": [255, 255, 240], ++ "khaki": [240, 230, 140], ++ "lavender": [230, 230, 250], ++ "lavenderblush": [255, 240, 245], ++ "lawngreen": [124, 252, 0], ++ "lemonchiffon": [255, 250, 205], ++ "lightblue": [173, 216, 230], ++ "lightcoral": [240, 128, 128], ++ "lightcyan": [224, 255, 255], ++ "lightgoldenrodyellow": [250, 250, 210], ++ "lightgray": [211, 211, 211], ++ "lightgreen": [144, 238, 144], ++ "lightgrey": [211, 211, 211], ++ "lightpink": [255, 182, 193], ++ "lightsalmon": [255, 160, 122], ++ "lightseagreen": [32, 178, 170], ++ "lightskyblue": [135, 206, 250], ++ "lightslategray": [119, 136, 153], ++ "lightslategrey": [119, 136, 153], ++ "lightsteelblue": [176, 196, 222], ++ "lightyellow": [255, 255, 224], ++ "lime": [0, 255, 0], ++ "limegreen": [50, 205, 50], ++ "linen": [250, 240, 230], ++ "magenta": [255, 0, 255], ++ "maroon": [128, 0, 0], ++ "mediumaquamarine": [102, 205, 170], ++ "mediumblue": [0, 0, 205], ++ "mediumorchid": [186, 85, 211], ++ "mediumpurple": [147, 112, 219], ++ "mediumseagreen": [60, 179, 113], ++ "mediumslateblue": [123, 104, 238], ++ "mediumspringgreen": [0, 250, 154], ++ "mediumturquoise": [72, 209, 204], ++ "mediumvioletred": [199, 21, 133], ++ "midnightblue": [25, 25, 112], ++ "mintcream": [245, 255, 250], ++ "mistyrose": [255, 228, 225], ++ "moccasin": [255, 228, 181], ++ "navajowhite": [255, 222, 173], ++ "navy": [0, 0, 128], ++ "oldlace": [253, 245, 230], ++ "olive": [128, 128, 0], ++ "olivedrab": [107, 142, 35], ++ "orange": [255, 165, 0], ++ "orangered": [255, 69, 0], ++ "orchid": [218, 112, 214], ++ "palegoldenrod": [238, 232, 170], ++ "palegreen": [152, 251, 152], ++ "paleturquoise": [175, 238, 238], ++ "palevioletred": [219, 112, 147], ++ "papayawhip": [255, 239, 213], ++ "peachpuff": [255, 218, 185], ++ "peru": [205, 133, 63], ++ "pink": [255, 192, 203], ++ "plum": [221, 160, 221], ++ "powderblue": [176, 224, 230], ++ "purple": [128, 0, 128], ++ "rebeccapurple": [102, 51, 153], ++ "red": [255, 0, 0], ++ "rosybrown": [188, 143, 143], ++ "royalblue": [65, 105, 225], ++ "saddlebrown": [139, 69, 19], ++ "salmon": [250, 128, 114], ++ "sandybrown": [244, 164, 96], ++ "seagreen": [46, 139, 87], ++ "seashell": [255, 245, 238], ++ "sienna": [160, 82, 45], ++ "silver": [192, 192, 192], ++ "skyblue": [135, 206, 235], ++ "slateblue": [106, 90, 205], ++ "slategray": [112, 128, 144], ++ "slategrey": [112, 128, 144], ++ "snow": [255, 250, 250], ++ "springgreen": [0, 255, 127], ++ "steelblue": [70, 130, 180], ++ "tan": [210, 180, 140], ++ "teal": [0, 128, 128], ++ "thistle": [216, 191, 216], ++ "tomato": [255, 99, 71], ++ "turquoise": [64, 224, 208], ++ "violet": [238, 130, 238], ++ "wheat": [245, 222, 179], ++ "white": [255, 255, 255], ++ "whitesmoke": [245, 245, 245], ++ "yellow": [255, 255, 0], ++ "yellowgreen": [154, 205, 50] ++}; ++ ++var conversions$2 = createCommonjsModule(function (module) { ++ /* MIT license */ ++ // NOTE: conversions should only return primitive values (i.e. arrays, or ++ // values that give correct `typeof` results). ++ // do not use box values types (i.e. Number(), String(), etc.) ++ var reverseKeywords = {}; ++ ++ for (var key in colorName$2) { ++ if (colorName$2.hasOwnProperty(key)) { ++ reverseKeywords[colorName$2[key]] = key; ++ } ++ } ++ ++ var convert = module.exports = { ++ rgb: { ++ channels: 3, ++ labels: 'rgb' ++ }, ++ hsl: { ++ channels: 3, ++ labels: 'hsl' ++ }, ++ hsv: { ++ channels: 3, ++ labels: 'hsv' ++ }, ++ hwb: { ++ channels: 3, ++ labels: 'hwb' ++ }, ++ cmyk: { ++ channels: 4, ++ labels: 'cmyk' ++ }, ++ xyz: { ++ channels: 3, ++ labels: 'xyz' ++ }, ++ lab: { ++ channels: 3, ++ labels: 'lab' ++ }, ++ lch: { ++ channels: 3, ++ labels: 'lch' ++ }, ++ hex: { ++ channels: 1, ++ labels: ['hex'] ++ }, ++ keyword: { ++ channels: 1, ++ labels: ['keyword'] ++ }, ++ ansi16: { ++ channels: 1, ++ labels: ['ansi16'] ++ }, ++ ansi256: { ++ channels: 1, ++ labels: ['ansi256'] ++ }, ++ hcg: { ++ channels: 3, ++ labels: ['h', 'c', 'g'] ++ }, ++ apple: { ++ channels: 3, ++ labels: ['r16', 'g16', 'b16'] ++ }, ++ gray: { ++ channels: 1, ++ labels: ['gray'] ++ } ++ }; // hide .channels and .labels properties ++ ++ for (var model in convert) { ++ if (convert.hasOwnProperty(model)) { ++ if (!('channels' in convert[model])) { ++ throw new Error('missing channels property: ' + model); ++ } ++ ++ if (!('labels' in convert[model])) { ++ throw new Error('missing channel labels property: ' + model); ++ } ++ ++ if (convert[model].labels.length !== convert[model].channels) { ++ throw new Error('channel and label counts mismatch: ' + model); ++ } ++ ++ var channels = convert[model].channels; ++ var labels = convert[model].labels; ++ delete convert[model].channels; ++ delete convert[model].labels; ++ Object.defineProperty(convert[model], 'channels', { ++ value: channels ++ }); ++ Object.defineProperty(convert[model], 'labels', { ++ value: labels ++ }); ++ } ++ } ++ ++ convert.rgb.hsl = function (rgb) { ++ var r = rgb[0] / 255; ++ var g = rgb[1] / 255; ++ var b = rgb[2] / 255; ++ var min = Math.min(r, g, b); ++ var max = Math.max(r, g, b); ++ var delta = max - min; ++ var h; ++ var s; ++ var l; ++ ++ if (max === min) { ++ h = 0; ++ } else if (r === max) { ++ h = (g - b) / delta; ++ } else if (g === max) { ++ h = 2 + (b - r) / delta; ++ } else if (b === max) { ++ h = 4 + (r - g) / delta; ++ } ++ ++ h = Math.min(h * 60, 360); ++ ++ if (h < 0) { ++ h += 360; ++ } ++ ++ l = (min + max) / 2; ++ ++ if (max === min) { ++ s = 0; ++ } else if (l <= 0.5) { ++ s = delta / (max + min); ++ } else { ++ s = delta / (2 - max - min); ++ } ++ ++ return [h, s * 100, l * 100]; ++ }; ++ ++ convert.rgb.hsv = function (rgb) { ++ var rdif; ++ var gdif; ++ var bdif; ++ var h; ++ var s; ++ var r = rgb[0] / 255; ++ var g = rgb[1] / 255; ++ var b = rgb[2] / 255; ++ var v = Math.max(r, g, b); ++ var diff = v - Math.min(r, g, b); ++ ++ var diffc = function (c) { ++ return (v - c) / 6 / diff + 1 / 2; ++ }; ++ ++ if (diff === 0) { ++ h = s = 0; ++ } else { ++ s = diff / v; ++ rdif = diffc(r); ++ gdif = diffc(g); ++ bdif = diffc(b); ++ ++ if (r === v) { ++ h = bdif - gdif; ++ } else if (g === v) { ++ h = 1 / 3 + rdif - bdif; ++ } else if (b === v) { ++ h = 2 / 3 + gdif - rdif; ++ } ++ ++ if (h < 0) { ++ h += 1; ++ } else if (h > 1) { ++ h -= 1; ++ } ++ } ++ ++ return [h * 360, s * 100, v * 100]; ++ }; ++ ++ convert.rgb.hwb = function (rgb) { ++ var r = rgb[0]; ++ var g = rgb[1]; ++ var b = rgb[2]; ++ var h = convert.rgb.hsl(rgb)[0]; ++ var w = 1 / 255 * Math.min(r, Math.min(g, b)); ++ b = 1 - 1 / 255 * Math.max(r, Math.max(g, b)); ++ return [h, w * 100, b * 100]; ++ }; ++ ++ convert.rgb.cmyk = function (rgb) { ++ var r = rgb[0] / 255; ++ var g = rgb[1] / 255; ++ var b = rgb[2] / 255; ++ var c; ++ var m; ++ var y; ++ var k; ++ k = Math.min(1 - r, 1 - g, 1 - b); ++ c = (1 - r - k) / (1 - k) || 0; ++ m = (1 - g - k) / (1 - k) || 0; ++ y = (1 - b - k) / (1 - k) || 0; ++ return [c * 100, m * 100, y * 100, k * 100]; ++ }; ++ /** ++ * See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance ++ * */ ++ ++ ++ function comparativeDistance(x, y) { ++ return Math.pow(x[0] - y[0], 2) + Math.pow(x[1] - y[1], 2) + Math.pow(x[2] - y[2], 2); ++ } ++ ++ convert.rgb.keyword = function (rgb) { ++ var reversed = reverseKeywords[rgb]; ++ ++ if (reversed) { ++ return reversed; ++ } ++ ++ var currentClosestDistance = Infinity; ++ var currentClosestKeyword; ++ ++ for (var keyword in colorName$2) { ++ if (colorName$2.hasOwnProperty(keyword)) { ++ var value = colorName$2[keyword]; // Compute comparative distance ++ ++ var distance = comparativeDistance(rgb, value); // Check if its less, if so set as closest ++ ++ if (distance < currentClosestDistance) { ++ currentClosestDistance = distance; ++ currentClosestKeyword = keyword; ++ } ++ } ++ } ++ ++ return currentClosestKeyword; ++ }; ++ ++ convert.keyword.rgb = function (keyword) { ++ return colorName$2[keyword]; ++ }; ++ ++ convert.rgb.xyz = function (rgb) { ++ var r = rgb[0] / 255; ++ var g = rgb[1] / 255; ++ var b = rgb[2] / 255; // assume sRGB ++ ++ r = r > 0.04045 ? Math.pow((r + 0.055) / 1.055, 2.4) : r / 12.92; ++ g = g > 0.04045 ? Math.pow((g + 0.055) / 1.055, 2.4) : g / 12.92; ++ b = b > 0.04045 ? Math.pow((b + 0.055) / 1.055, 2.4) : b / 12.92; ++ var x = r * 0.4124 + g * 0.3576 + b * 0.1805; ++ var y = r * 0.2126 + g * 0.7152 + b * 0.0722; ++ var z = r * 0.0193 + g * 0.1192 + b * 0.9505; ++ return [x * 100, y * 100, z * 100]; ++ }; ++ ++ convert.rgb.lab = function (rgb) { ++ var xyz = convert.rgb.xyz(rgb); ++ var x = xyz[0]; ++ var y = xyz[1]; ++ var z = xyz[2]; ++ var l; ++ var a; ++ var b; ++ x /= 95.047; ++ y /= 100; ++ z /= 108.883; ++ x = x > 0.008856 ? Math.pow(x, 1 / 3) : 7.787 * x + 16 / 116; ++ y = y > 0.008856 ? Math.pow(y, 1 / 3) : 7.787 * y + 16 / 116; ++ z = z > 0.008856 ? Math.pow(z, 1 / 3) : 7.787 * z + 16 / 116; ++ l = 116 * y - 16; ++ a = 500 * (x - y); ++ b = 200 * (y - z); ++ return [l, a, b]; ++ }; ++ ++ convert.hsl.rgb = function (hsl) { ++ var h = hsl[0] / 360; ++ var s = hsl[1] / 100; ++ var l = hsl[2] / 100; ++ var t1; ++ var t2; ++ var t3; ++ var rgb; ++ var val; ++ ++ if (s === 0) { ++ val = l * 255; ++ return [val, val, val]; ++ } ++ ++ if (l < 0.5) { ++ t2 = l * (1 + s); ++ } else { ++ t2 = l + s - l * s; ++ } ++ ++ t1 = 2 * l - t2; ++ rgb = [0, 0, 0]; ++ ++ for (var i = 0; i < 3; i++) { ++ t3 = h + 1 / 3 * -(i - 1); ++ ++ if (t3 < 0) { ++ t3++; ++ } ++ ++ if (t3 > 1) { ++ t3--; ++ } ++ ++ if (6 * t3 < 1) { ++ val = t1 + (t2 - t1) * 6 * t3; ++ } else if (2 * t3 < 1) { ++ val = t2; ++ } else if (3 * t3 < 2) { ++ val = t1 + (t2 - t1) * (2 / 3 - t3) * 6; ++ } else { ++ val = t1; ++ } ++ ++ rgb[i] = val * 255; ++ } ++ ++ return rgb; ++ }; ++ ++ convert.hsl.hsv = function (hsl) { ++ var h = hsl[0]; ++ var s = hsl[1] / 100; ++ var l = hsl[2] / 100; ++ var smin = s; ++ var lmin = Math.max(l, 0.01); ++ var sv; ++ var v; ++ l *= 2; ++ s *= l <= 1 ? l : 2 - l; ++ smin *= lmin <= 1 ? lmin : 2 - lmin; ++ v = (l + s) / 2; ++ sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l + s); ++ return [h, sv * 100, v * 100]; ++ }; ++ ++ convert.hsv.rgb = function (hsv) { ++ var h = hsv[0] / 60; ++ var s = hsv[1] / 100; ++ var v = hsv[2] / 100; ++ var hi = Math.floor(h) % 6; ++ var f = h - Math.floor(h); ++ var p = 255 * v * (1 - s); ++ var q = 255 * v * (1 - s * f); ++ var t = 255 * v * (1 - s * (1 - f)); ++ v *= 255; ++ ++ switch (hi) { ++ case 0: ++ return [v, t, p]; ++ ++ case 1: ++ return [q, v, p]; ++ ++ case 2: ++ return [p, v, t]; ++ ++ case 3: ++ return [p, q, v]; ++ ++ case 4: ++ return [t, p, v]; ++ ++ case 5: ++ return [v, p, q]; ++ } ++ }; ++ ++ convert.hsv.hsl = function (hsv) { ++ var h = hsv[0]; ++ var s = hsv[1] / 100; ++ var v = hsv[2] / 100; ++ var vmin = Math.max(v, 0.01); ++ var lmin; ++ var sl; ++ var l; ++ l = (2 - s) * v; ++ lmin = (2 - s) * vmin; ++ sl = s * vmin; ++ sl /= lmin <= 1 ? lmin : 2 - lmin; ++ sl = sl || 0; ++ l /= 2; ++ return [h, sl * 100, l * 100]; ++ }; // http://dev.w3.org/csswg/css-color/#hwb-to-rgb ++ ++ ++ convert.hwb.rgb = function (hwb) { ++ var h = hwb[0] / 360; ++ var wh = hwb[1] / 100; ++ var bl = hwb[2] / 100; ++ var ratio = wh + bl; ++ var i; ++ var v; ++ var f; ++ var n; // wh + bl cant be > 1 ++ ++ if (ratio > 1) { ++ wh /= ratio; ++ bl /= ratio; ++ } ++ ++ i = Math.floor(6 * h); ++ v = 1 - bl; ++ f = 6 * h - i; ++ ++ if ((i & 0x01) !== 0) { ++ f = 1 - f; ++ } ++ ++ n = wh + f * (v - wh); // linear interpolation ++ ++ var r; ++ var g; ++ var b; ++ ++ switch (i) { ++ default: ++ case 6: ++ case 0: ++ r = v; ++ g = n; ++ b = wh; ++ break; ++ ++ case 1: ++ r = n; ++ g = v; ++ b = wh; ++ break; ++ ++ case 2: ++ r = wh; ++ g = v; ++ b = n; ++ break; ++ ++ case 3: ++ r = wh; ++ g = n; ++ b = v; ++ break; ++ ++ case 4: ++ r = n; ++ g = wh; ++ b = v; ++ break; ++ ++ case 5: ++ r = v; ++ g = wh; ++ b = n; ++ break; ++ } ++ ++ return [r * 255, g * 255, b * 255]; ++ }; ++ ++ convert.cmyk.rgb = function (cmyk) { ++ var c = cmyk[0] / 100; ++ var m = cmyk[1] / 100; ++ var y = cmyk[2] / 100; ++ var k = cmyk[3] / 100; ++ var r; ++ var g; ++ var b; ++ r = 1 - Math.min(1, c * (1 - k) + k); ++ g = 1 - Math.min(1, m * (1 - k) + k); ++ b = 1 - Math.min(1, y * (1 - k) + k); ++ return [r * 255, g * 255, b * 255]; ++ }; ++ ++ convert.xyz.rgb = function (xyz) { ++ var x = xyz[0] / 100; ++ var y = xyz[1] / 100; ++ var z = xyz[2] / 100; ++ var r; ++ var g; ++ var b; ++ r = x * 3.2406 + y * -1.5372 + z * -0.4986; ++ g = x * -0.9689 + y * 1.8758 + z * 0.0415; ++ b = x * 0.0557 + y * -0.2040 + z * 1.0570; // assume sRGB ++ ++ r = r > 0.0031308 ? 1.055 * Math.pow(r, 1.0 / 2.4) - 0.055 : r * 12.92; ++ g = g > 0.0031308 ? 1.055 * Math.pow(g, 1.0 / 2.4) - 0.055 : g * 12.92; ++ b = b > 0.0031308 ? 1.055 * Math.pow(b, 1.0 / 2.4) - 0.055 : b * 12.92; ++ r = Math.min(Math.max(0, r), 1); ++ g = Math.min(Math.max(0, g), 1); ++ b = Math.min(Math.max(0, b), 1); ++ return [r * 255, g * 255, b * 255]; ++ }; ++ ++ convert.xyz.lab = function (xyz) { ++ var x = xyz[0]; ++ var y = xyz[1]; ++ var z = xyz[2]; ++ var l; ++ var a; ++ var b; ++ x /= 95.047; ++ y /= 100; ++ z /= 108.883; ++ x = x > 0.008856 ? Math.pow(x, 1 / 3) : 7.787 * x + 16 / 116; ++ y = y > 0.008856 ? Math.pow(y, 1 / 3) : 7.787 * y + 16 / 116; ++ z = z > 0.008856 ? Math.pow(z, 1 / 3) : 7.787 * z + 16 / 116; ++ l = 116 * y - 16; ++ a = 500 * (x - y); ++ b = 200 * (y - z); ++ return [l, a, b]; ++ }; ++ ++ convert.lab.xyz = function (lab) { ++ var l = lab[0]; ++ var a = lab[1]; ++ var b = lab[2]; ++ var x; ++ var y; ++ var z; ++ y = (l + 16) / 116; ++ x = a / 500 + y; ++ z = y - b / 200; ++ var y2 = Math.pow(y, 3); ++ var x2 = Math.pow(x, 3); ++ var z2 = Math.pow(z, 3); ++ y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787; ++ x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787; ++ z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787; ++ x *= 95.047; ++ y *= 100; ++ z *= 108.883; ++ return [x, y, z]; ++ }; ++ ++ convert.lab.lch = function (lab) { ++ var l = lab[0]; ++ var a = lab[1]; ++ var b = lab[2]; ++ var hr; ++ var h; ++ var c; ++ hr = Math.atan2(b, a); ++ h = hr * 360 / 2 / Math.PI; ++ ++ if (h < 0) { ++ h += 360; ++ } ++ ++ c = Math.sqrt(a * a + b * b); ++ return [l, c, h]; ++ }; ++ ++ convert.lch.lab = function (lch) { ++ var l = lch[0]; ++ var c = lch[1]; ++ var h = lch[2]; ++ var a; ++ var b; ++ var hr; ++ hr = h / 360 * 2 * Math.PI; ++ a = c * Math.cos(hr); ++ b = c * Math.sin(hr); ++ return [l, a, b]; ++ }; ++ ++ convert.rgb.ansi16 = function (args) { ++ var r = args[0]; ++ var g = args[1]; ++ var b = args[2]; ++ var value = 1 in arguments ? arguments[1] : convert.rgb.hsv(args)[2]; // hsv -> ansi16 optimization ++ ++ value = Math.round(value / 50); ++ ++ if (value === 0) { ++ return 30; ++ } ++ ++ var ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255)); ++ ++ if (value === 2) { ++ ansi += 60; ++ } ++ ++ return ansi; ++ }; ++ ++ convert.hsv.ansi16 = function (args) { ++ // optimization here; we already know the value and don't need to get ++ // it converted for us. ++ return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]); ++ }; ++ ++ convert.rgb.ansi256 = function (args) { ++ var r = args[0]; ++ var g = args[1]; ++ var b = args[2]; // we use the extended greyscale palette here, with the exception of ++ // black and white. normal palette only has 4 greyscale shades. ++ ++ if (r === g && g === b) { ++ if (r < 8) { ++ return 16; ++ } ++ ++ if (r > 248) { ++ return 231; ++ } ++ ++ return Math.round((r - 8) / 247 * 24) + 232; ++ } ++ ++ var ansi = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5); ++ return ansi; ++ }; ++ ++ convert.ansi16.rgb = function (args) { ++ var color = args % 10; // handle greyscale ++ ++ if (color === 0 || color === 7) { ++ if (args > 50) { ++ color += 3.5; ++ } ++ ++ color = color / 10.5 * 255; ++ return [color, color, color]; ++ } ++ ++ var mult = (~~(args > 50) + 1) * 0.5; ++ var r = (color & 1) * mult * 255; ++ var g = (color >> 1 & 1) * mult * 255; ++ var b = (color >> 2 & 1) * mult * 255; ++ return [r, g, b]; ++ }; ++ ++ convert.ansi256.rgb = function (args) { ++ // handle greyscale ++ if (args >= 232) { ++ var c = (args - 232) * 10 + 8; ++ return [c, c, c]; ++ } ++ ++ args -= 16; ++ var rem; ++ var r = Math.floor(args / 36) / 5 * 255; ++ var g = Math.floor((rem = args % 36) / 6) / 5 * 255; ++ var b = rem % 6 / 5 * 255; ++ return [r, g, b]; ++ }; ++ ++ convert.rgb.hex = function (args) { ++ var integer = ((Math.round(args[0]) & 0xFF) << 16) + ((Math.round(args[1]) & 0xFF) << 8) + (Math.round(args[2]) & 0xFF); ++ var string = integer.toString(16).toUpperCase(); ++ return '000000'.substring(string.length) + string; ++ }; ++ ++ convert.hex.rgb = function (args) { ++ var match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i); ++ ++ if (!match) { ++ return [0, 0, 0]; ++ } ++ ++ var colorString = match[0]; ++ ++ if (match[0].length === 3) { ++ colorString = colorString.split('').map(function (char) { ++ return char + char; ++ }).join(''); ++ } ++ ++ var integer = parseInt(colorString, 16); ++ var r = integer >> 16 & 0xFF; ++ var g = integer >> 8 & 0xFF; ++ var b = integer & 0xFF; ++ return [r, g, b]; ++ }; ++ ++ convert.rgb.hcg = function (rgb) { ++ var r = rgb[0] / 255; ++ var g = rgb[1] / 255; ++ var b = rgb[2] / 255; ++ var max = Math.max(Math.max(r, g), b); ++ var min = Math.min(Math.min(r, g), b); ++ var chroma = max - min; ++ var grayscale; ++ var hue; ++ ++ if (chroma < 1) { ++ grayscale = min / (1 - chroma); ++ } else { ++ grayscale = 0; ++ } ++ ++ if (chroma <= 0) { ++ hue = 0; ++ } else if (max === r) { ++ hue = (g - b) / chroma % 6; ++ } else if (max === g) { ++ hue = 2 + (b - r) / chroma; ++ } else { ++ hue = 4 + (r - g) / chroma + 4; ++ } ++ ++ hue /= 6; ++ hue %= 1; ++ return [hue * 360, chroma * 100, grayscale * 100]; ++ }; ++ ++ convert.hsl.hcg = function (hsl) { ++ var s = hsl[1] / 100; ++ var l = hsl[2] / 100; ++ var c = 1; ++ var f = 0; ++ ++ if (l < 0.5) { ++ c = 2.0 * s * l; ++ } else { ++ c = 2.0 * s * (1.0 - l); ++ } ++ ++ if (c < 1.0) { ++ f = (l - 0.5 * c) / (1.0 - c); ++ } ++ ++ return [hsl[0], c * 100, f * 100]; ++ }; ++ ++ convert.hsv.hcg = function (hsv) { ++ var s = hsv[1] / 100; ++ var v = hsv[2] / 100; ++ var c = s * v; ++ var f = 0; ++ ++ if (c < 1.0) { ++ f = (v - c) / (1 - c); ++ } ++ ++ return [hsv[0], c * 100, f * 100]; ++ }; ++ ++ convert.hcg.rgb = function (hcg) { ++ var h = hcg[0] / 360; ++ var c = hcg[1] / 100; ++ var g = hcg[2] / 100; ++ ++ if (c === 0.0) { ++ return [g * 255, g * 255, g * 255]; ++ } ++ ++ var pure = [0, 0, 0]; ++ var hi = h % 1 * 6; ++ var v = hi % 1; ++ var w = 1 - v; ++ var mg = 0; ++ ++ switch (Math.floor(hi)) { ++ case 0: ++ pure[0] = 1; ++ pure[1] = v; ++ pure[2] = 0; ++ break; ++ ++ case 1: ++ pure[0] = w; ++ pure[1] = 1; ++ pure[2] = 0; ++ break; ++ ++ case 2: ++ pure[0] = 0; ++ pure[1] = 1; ++ pure[2] = v; ++ break; ++ ++ case 3: ++ pure[0] = 0; ++ pure[1] = w; ++ pure[2] = 1; ++ break; ++ ++ case 4: ++ pure[0] = v; ++ pure[1] = 0; ++ pure[2] = 1; ++ break; ++ ++ default: ++ pure[0] = 1; ++ pure[1] = 0; ++ pure[2] = w; ++ } ++ ++ mg = (1.0 - c) * g; ++ return [(c * pure[0] + mg) * 255, (c * pure[1] + mg) * 255, (c * pure[2] + mg) * 255]; ++ }; ++ ++ convert.hcg.hsv = function (hcg) { ++ var c = hcg[1] / 100; ++ var g = hcg[2] / 100; ++ var v = c + g * (1.0 - c); ++ var f = 0; ++ ++ if (v > 0.0) { ++ f = c / v; ++ } ++ ++ return [hcg[0], f * 100, v * 100]; ++ }; ++ ++ convert.hcg.hsl = function (hcg) { ++ var c = hcg[1] / 100; ++ var g = hcg[2] / 100; ++ var l = g * (1.0 - c) + 0.5 * c; ++ var s = 0; ++ ++ if (l > 0.0 && l < 0.5) { ++ s = c / (2 * l); ++ } else if (l >= 0.5 && l < 1.0) { ++ s = c / (2 * (1 - l)); ++ } ++ ++ return [hcg[0], s * 100, l * 100]; ++ }; ++ ++ convert.hcg.hwb = function (hcg) { ++ var c = hcg[1] / 100; ++ var g = hcg[2] / 100; ++ var v = c + g * (1.0 - c); ++ return [hcg[0], (v - c) * 100, (1 - v) * 100]; ++ }; ++ ++ convert.hwb.hcg = function (hwb) { ++ var w = hwb[1] / 100; ++ var b = hwb[2] / 100; ++ var v = 1 - b; ++ var c = v - w; ++ var g = 0; ++ ++ if (c < 1) { ++ g = (v - c) / (1 - c); ++ } ++ ++ return [hwb[0], c * 100, g * 100]; ++ }; ++ ++ convert.apple.rgb = function (apple) { ++ return [apple[0] / 65535 * 255, apple[1] / 65535 * 255, apple[2] / 65535 * 255]; ++ }; ++ ++ convert.rgb.apple = function (rgb) { ++ return [rgb[0] / 255 * 65535, rgb[1] / 255 * 65535, rgb[2] / 255 * 65535]; ++ }; ++ ++ convert.gray.rgb = function (args) { ++ return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255]; ++ }; ++ ++ convert.gray.hsl = convert.gray.hsv = function (args) { ++ return [0, 0, args[0]]; ++ }; ++ ++ convert.gray.hwb = function (gray) { ++ return [0, 100, gray[0]]; ++ }; ++ ++ convert.gray.cmyk = function (gray) { ++ return [0, 0, 0, gray[0]]; ++ }; ++ ++ convert.gray.lab = function (gray) { ++ return [gray[0], 0, 0]; ++ }; ++ ++ convert.gray.hex = function (gray) { ++ var val = Math.round(gray[0] / 100 * 255) & 0xFF; ++ var integer = (val << 16) + (val << 8) + val; ++ var string = integer.toString(16).toUpperCase(); ++ return '000000'.substring(string.length) + string; ++ }; ++ ++ convert.rgb.gray = function (rgb) { ++ var val = (rgb[0] + rgb[1] + rgb[2]) / 3; ++ return [val / 255 * 100]; ++ }; ++}); ++var conversions_1$1 = conversions$2.rgb; ++var conversions_2$1 = conversions$2.hsl; ++var conversions_3$1 = conversions$2.hsv; ++var conversions_4$1 = conversions$2.hwb; ++var conversions_5$1 = conversions$2.cmyk; ++var conversions_6$1 = conversions$2.xyz; ++var conversions_7$1 = conversions$2.lab; ++var conversions_8$1 = conversions$2.lch; ++var conversions_9$1 = conversions$2.hex; ++var conversions_10$1 = conversions$2.keyword; ++var conversions_11$1 = conversions$2.ansi16; ++var conversions_12$1 = conversions$2.ansi256; ++var conversions_13$1 = conversions$2.hcg; ++var conversions_14$1 = conversions$2.apple; ++var conversions_15$1 = conversions$2.gray; ++ ++/* ++ this function routes a model to all other models. ++ ++ all functions that are routed have a property `.conversion` attached ++ to the returned synthetic function. This property is an array ++ of strings, each with the steps in between the 'from' and 'to' ++ color models (inclusive). ++ ++ conversions that are not possible simply are not included. ++*/ ++ ++function buildGraph$2() { ++ var graph = {}; // https://jsperf.com/object-keys-vs-for-in-with-closure/3 ++ ++ var models = Object.keys(conversions$2); ++ ++ for (var len = models.length, i = 0; i < len; i++) { ++ graph[models[i]] = { ++ // http://jsperf.com/1-vs-infinity ++ // micro-opt, but this is simple. ++ distance: -1, ++ parent: null ++ }; ++ } ++ ++ return graph; ++} // https://en.wikipedia.org/wiki/Breadth-first_search ++ ++ ++function deriveBFS$2(fromModel) { ++ var graph = buildGraph$2(); ++ var queue = [fromModel]; // unshift -> queue -> pop ++ ++ graph[fromModel].distance = 0; ++ ++ while (queue.length) { ++ var current = queue.pop(); ++ var adjacents = Object.keys(conversions$2[current]); ++ ++ for (var len = adjacents.length, i = 0; i < len; i++) { ++ var adjacent = adjacents[i]; ++ var node = graph[adjacent]; ++ ++ if (node.distance === -1) { ++ node.distance = graph[current].distance + 1; ++ node.parent = current; ++ queue.unshift(adjacent); ++ } ++ } ++ } ++ ++ return graph; ++} ++ ++function link$2(from, to) { ++ return function (args) { ++ return to(from(args)); ++ }; ++} ++ ++function wrapConversion$2(toModel, graph) { ++ var path = [graph[toModel].parent, toModel]; ++ var fn = conversions$2[graph[toModel].parent][toModel]; ++ var cur = graph[toModel].parent; ++ ++ while (graph[cur].parent) { ++ path.unshift(graph[cur].parent); ++ fn = link$2(conversions$2[graph[cur].parent][cur], fn); ++ cur = graph[cur].parent; ++ } ++ ++ fn.conversion = path; ++ return fn; ++} ++ ++var route$2 = function (fromModel) { ++ var graph = deriveBFS$2(fromModel); ++ var conversion = {}; ++ var models = Object.keys(graph); ++ ++ for (var len = models.length, i = 0; i < len; i++) { ++ var toModel = models[i]; ++ var node = graph[toModel]; ++ ++ if (node.parent === null) { ++ // no possible conversion, or this node is the source model. ++ continue; ++ } ++ ++ conversion[toModel] = wrapConversion$2(toModel, graph); ++ } ++ ++ return conversion; ++}; ++ ++var convert$3 = {}; ++var models$2 = Object.keys(conversions$2); ++ ++function wrapRaw$2(fn) { ++ var wrappedFn = function (args) { ++ if (args === undefined || args === null) { ++ return args; ++ } ++ ++ if (arguments.length > 1) { ++ args = Array.prototype.slice.call(arguments); ++ } ++ ++ return fn(args); ++ }; // preserve .conversion property if there is one ++ ++ ++ if ('conversion' in fn) { ++ wrappedFn.conversion = fn.conversion; ++ } ++ ++ return wrappedFn; ++} ++ ++function wrapRounded$2(fn) { ++ var wrappedFn = function (args) { ++ if (args === undefined || args === null) { ++ return args; ++ } ++ ++ if (arguments.length > 1) { ++ args = Array.prototype.slice.call(arguments); ++ } ++ ++ var result = fn(args); // we're assuming the result is an array here. ++ // see notice in conversions.js; don't use box types ++ // in conversion functions. ++ ++ if (typeof result === 'object') { ++ for (var len = result.length, i = 0; i < len; i++) { ++ result[i] = Math.round(result[i]); ++ } ++ } ++ ++ return result; ++ }; // preserve .conversion property if there is one ++ ++ ++ if ('conversion' in fn) { ++ wrappedFn.conversion = fn.conversion; ++ } ++ ++ return wrappedFn; ++} ++ ++models$2.forEach(function (fromModel) { ++ convert$3[fromModel] = {}; ++ Object.defineProperty(convert$3[fromModel], 'channels', { ++ value: conversions$2[fromModel].channels ++ }); ++ Object.defineProperty(convert$3[fromModel], 'labels', { ++ value: conversions$2[fromModel].labels ++ }); ++ var routes = route$2(fromModel); ++ var routeModels = Object.keys(routes); ++ routeModels.forEach(function (toModel) { ++ var fn = routes[toModel]; ++ convert$3[fromModel][toModel] = wrapRounded$2(fn); ++ convert$3[fromModel][toModel].raw = wrapRaw$2(fn); ++ }); ++}); ++var colorConvert$2 = convert$3; ++ ++var ansiStyles$2 = createCommonjsModule(function (module) { ++ ++ const wrapAnsi16 = (fn, offset) => function () { ++ const code = fn.apply(colorConvert$2, arguments); ++ return `\u001B[${code + offset}m`; ++ }; ++ ++ const wrapAnsi256 = (fn, offset) => function () { ++ const code = fn.apply(colorConvert$2, arguments); ++ return `\u001B[${38 + offset};5;${code}m`; ++ }; ++ ++ const wrapAnsi16m = (fn, offset) => function () { ++ const rgb = fn.apply(colorConvert$2, arguments); ++ return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`; ++ }; ++ ++ function assembleStyles() { ++ const codes = new Map(); ++ const styles = { ++ modifier: { ++ reset: [0, 0], ++ // 21 isn't widely supported and 22 does the same thing ++ bold: [1, 22], ++ dim: [2, 22], ++ italic: [3, 23], ++ underline: [4, 24], ++ inverse: [7, 27], ++ hidden: [8, 28], ++ strikethrough: [9, 29] ++ }, ++ color: { ++ black: [30, 39], ++ red: [31, 39], ++ green: [32, 39], ++ yellow: [33, 39], ++ blue: [34, 39], ++ magenta: [35, 39], ++ cyan: [36, 39], ++ white: [37, 39], ++ gray: [90, 39], ++ // Bright color ++ redBright: [91, 39], ++ greenBright: [92, 39], ++ yellowBright: [93, 39], ++ blueBright: [94, 39], ++ magentaBright: [95, 39], ++ cyanBright: [96, 39], ++ whiteBright: [97, 39] ++ }, ++ bgColor: { ++ bgBlack: [40, 49], ++ bgRed: [41, 49], ++ bgGreen: [42, 49], ++ bgYellow: [43, 49], ++ bgBlue: [44, 49], ++ bgMagenta: [45, 49], ++ bgCyan: [46, 49], ++ bgWhite: [47, 49], ++ // Bright color ++ bgBlackBright: [100, 49], ++ bgRedBright: [101, 49], ++ bgGreenBright: [102, 49], ++ bgYellowBright: [103, 49], ++ bgBlueBright: [104, 49], ++ bgMagentaBright: [105, 49], ++ bgCyanBright: [106, 49], ++ bgWhiteBright: [107, 49] ++ } ++ }; // Fix humans ++ ++ styles.color.grey = styles.color.gray; ++ ++ for (const groupName of Object.keys(styles)) { ++ const group = styles[groupName]; ++ ++ for (const styleName of Object.keys(group)) { ++ const style = group[styleName]; ++ styles[styleName] = { ++ open: `\u001B[${style[0]}m`, ++ close: `\u001B[${style[1]}m` ++ }; ++ group[styleName] = styles[styleName]; ++ codes.set(style[0], style[1]); ++ } ++ ++ Object.defineProperty(styles, groupName, { ++ value: group, ++ enumerable: false ++ }); ++ Object.defineProperty(styles, 'codes', { ++ value: codes, ++ enumerable: false ++ }); ++ } ++ ++ const ansi2ansi = n => n; ++ ++ const rgb2rgb = (r, g, b) => [r, g, b]; ++ ++ styles.color.close = '\u001B[39m'; ++ styles.bgColor.close = '\u001B[49m'; ++ styles.color.ansi = { ++ ansi: wrapAnsi16(ansi2ansi, 0) ++ }; ++ styles.color.ansi256 = { ++ ansi256: wrapAnsi256(ansi2ansi, 0) ++ }; ++ styles.color.ansi16m = { ++ rgb: wrapAnsi16m(rgb2rgb, 0) ++ }; ++ styles.bgColor.ansi = { ++ ansi: wrapAnsi16(ansi2ansi, 10) ++ }; ++ styles.bgColor.ansi256 = { ++ ansi256: wrapAnsi256(ansi2ansi, 10) ++ }; ++ styles.bgColor.ansi16m = { ++ rgb: wrapAnsi16m(rgb2rgb, 10) ++ }; ++ ++ for (let key of Object.keys(colorConvert$2)) { ++ if (typeof colorConvert$2[key] !== 'object') { ++ continue; ++ } ++ ++ const suite = colorConvert$2[key]; ++ ++ if (key === 'ansi16') { ++ key = 'ansi'; ++ } ++ ++ if ('ansi16' in suite) { ++ styles.color.ansi[key] = wrapAnsi16(suite.ansi16, 0); ++ styles.bgColor.ansi[key] = wrapAnsi16(suite.ansi16, 10); ++ } ++ ++ if ('ansi256' in suite) { ++ styles.color.ansi256[key] = wrapAnsi256(suite.ansi256, 0); ++ styles.bgColor.ansi256[key] = wrapAnsi256(suite.ansi256, 10); ++ } ++ ++ if ('rgb' in suite) { ++ styles.color.ansi16m[key] = wrapAnsi16m(suite.rgb, 0); ++ styles.bgColor.ansi16m[key] = wrapAnsi16m(suite.rgb, 10); ++ } ++ } ++ ++ return styles; ++ } // Make the export immutable ++ ++ ++ Object.defineProperty(module, 'exports', { ++ enumerable: true, ++ get: assembleStyles ++ }); ++}); ++ ++const env$2 = process.env; ++let forceColor$2; ++ ++if (hasFlag('no-color') || hasFlag('no-colors') || hasFlag('color=false')) { ++ forceColor$2 = false; ++} else if (hasFlag('color') || hasFlag('colors') || hasFlag('color=true') || hasFlag('color=always')) { ++ forceColor$2 = true; ++} ++ ++if ('FORCE_COLOR' in env$2) { ++ forceColor$2 = env$2.FORCE_COLOR.length === 0 || parseInt(env$2.FORCE_COLOR, 10) !== 0; ++} ++ ++function translateLevel$2(level) { ++ if (level === 0) { ++ return false; ++ } ++ ++ return { ++ level, ++ hasBasic: true, ++ has256: level >= 2, ++ has16m: level >= 3 ++ }; ++} ++ ++function supportsColor$2(stream) { ++ if (forceColor$2 === false) { ++ return 0; ++ } ++ ++ if (hasFlag('color=16m') || hasFlag('color=full') || hasFlag('color=truecolor')) { ++ return 3; ++ } ++ ++ if (hasFlag('color=256')) { ++ return 2; ++ } ++ ++ if (stream && !stream.isTTY && forceColor$2 !== true) { ++ return 0; ++ } ++ ++ const min = forceColor$2 ? 1 : 0; ++ ++ if (process.platform === 'win32') { ++ // Node.js 7.5.0 is the first version of Node.js to include a patch to ++ // libuv that enables 256 color output on Windows. Anything earlier and it ++ // won't work. However, here we target Node.js 8 at minimum as it is an LTS ++ // release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows ++ // release that supports 256 colors. Windows 10 build 14931 is the first release ++ // that supports 16m/TrueColor. ++ const osRelease = os.release().split('.'); ++ ++ if (Number(process.versions.node.split('.')[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) { ++ return Number(osRelease[2]) >= 14931 ? 3 : 2; ++ } ++ ++ return 1; ++ } ++ ++ if ('CI' in env$2) { ++ if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env$2) || env$2.CI_NAME === 'codeship') { ++ return 1; ++ } ++ ++ return min; ++ } ++ ++ if ('TEAMCITY_VERSION' in env$2) { ++ return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env$2.TEAMCITY_VERSION) ? 1 : 0; ++ } ++ ++ if (env$2.COLORTERM === 'truecolor') { ++ return 3; ++ } ++ ++ if ('TERM_PROGRAM' in env$2) { ++ const version = parseInt((env$2.TERM_PROGRAM_VERSION || '').split('.')[0], 10); ++ ++ switch (env$2.TERM_PROGRAM) { ++ case 'iTerm.app': ++ return version >= 3 ? 3 : 2; ++ ++ case 'Apple_Terminal': ++ return 2; ++ // No default ++ } ++ } ++ ++ if (/-256(color)?$/i.test(env$2.TERM)) { ++ return 2; ++ } ++ ++ if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env$2.TERM)) { ++ return 1; ++ } ++ ++ if ('COLORTERM' in env$2) { ++ return 1; ++ } ++ ++ if (env$2.TERM === 'dumb') { ++ return min; ++ } ++ ++ return min; ++} ++ ++function getSupportLevel$2(stream) { ++ const level = supportsColor$2(stream); ++ return translateLevel$2(level); ++} ++ ++var supportsColor_1$2 = { ++ supportsColor: getSupportLevel$2, ++ stdout: getSupportLevel$2(process.stdout), ++ stderr: getSupportLevel$2(process.stderr) ++}; ++ ++const TEMPLATE_REGEX$2 = /(?:\\(u[a-f\d]{4}|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi; ++const STYLE_REGEX$2 = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g; ++const STRING_REGEX$2 = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/; ++const ESCAPE_REGEX$2 = /\\(u[a-f\d]{4}|x[a-f\d]{2}|.)|([^\\])/gi; ++const ESCAPES$2 = new Map([['n', '\n'], ['r', '\r'], ['t', '\t'], ['b', '\b'], ['f', '\f'], ['v', '\v'], ['0', '\0'], ['\\', '\\'], ['e', '\u001B'], ['a', '\u0007']]); ++ ++function unescape$2(c) { ++ if (c[0] === 'u' && c.length === 5 || c[0] === 'x' && c.length === 3) { ++ return String.fromCharCode(parseInt(c.slice(1), 16)); ++ } ++ ++ return ESCAPES$2.get(c) || c; ++} ++ ++function parseArguments$2(name, args) { ++ const results = []; ++ const chunks = args.trim().split(/\s*,\s*/g); ++ let matches; ++ ++ for (const chunk of chunks) { ++ if (!isNaN(chunk)) { ++ results.push(Number(chunk)); ++ } else if (matches = chunk.match(STRING_REGEX$2)) { ++ results.push(matches[2].replace(ESCAPE_REGEX$2, (m, escape, chr) => escape ? unescape$2(escape) : chr)); ++ } else { ++ throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`); ++ } ++ } ++ ++ return results; ++} ++ ++function parseStyle$2(style) { ++ STYLE_REGEX$2.lastIndex = 0; ++ const results = []; ++ let matches; ++ ++ while ((matches = STYLE_REGEX$2.exec(style)) !== null) { ++ const name = matches[1]; ++ ++ if (matches[2]) { ++ const args = parseArguments$2(name, matches[2]); ++ results.push([name].concat(args)); ++ } else { ++ results.push([name]); ++ } ++ } ++ ++ return results; ++} ++ ++function buildStyle$2(chalk, styles) { ++ const enabled = {}; ++ ++ for (const layer of styles) { ++ for (const style of layer.styles) { ++ enabled[style[0]] = layer.inverse ? null : style.slice(1); ++ } ++ } ++ ++ let current = chalk; ++ ++ for (const styleName of Object.keys(enabled)) { ++ if (Array.isArray(enabled[styleName])) { ++ if (!(styleName in current)) { ++ throw new Error(`Unknown Chalk style: ${styleName}`); ++ } ++ ++ if (enabled[styleName].length > 0) { ++ current = current[styleName].apply(current, enabled[styleName]); ++ } else { ++ current = current[styleName]; ++ } ++ } ++ } ++ ++ return current; ++} ++ ++var templates$2 = (chalk, tmp) => { ++ const styles = []; ++ const chunks = []; ++ let chunk = []; // eslint-disable-next-line max-params ++ ++ tmp.replace(TEMPLATE_REGEX$2, (m, escapeChar, inverse, style, close, chr) => { ++ if (escapeChar) { ++ chunk.push(unescape$2(escapeChar)); ++ } else if (style) { ++ const str = chunk.join(''); ++ chunk = []; ++ chunks.push(styles.length === 0 ? str : buildStyle$2(chalk, styles)(str)); ++ styles.push({ ++ inverse, ++ styles: parseStyle$2(style) ++ }); ++ } else if (close) { ++ if (styles.length === 0) { ++ throw new Error('Found extraneous } in Chalk template literal'); ++ } ++ ++ chunks.push(buildStyle$2(chalk, styles)(chunk.join(''))); ++ chunk = []; ++ styles.pop(); ++ } else { ++ chunk.push(chr); ++ } ++ }); ++ chunks.push(chunk.join('')); ++ ++ if (styles.length > 0) { ++ const errMsg = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`; ++ throw new Error(errMsg); ++ } ++ ++ return chunks.join(''); ++}; ++ ++var chalk$2 = createCommonjsModule(function (module) { ++ ++ const stdoutColor = supportsColor_1$2.stdout; ++ const isSimpleWindowsTerm = process.platform === 'win32' && !(process.env.TERM || '').toLowerCase().startsWith('xterm'); // `supportsColor.level` → `ansiStyles.color[name]` mapping ++ ++ const levelMapping = ['ansi', 'ansi', 'ansi256', 'ansi16m']; // `color-convert` models to exclude from the Chalk API due to conflicts and such ++ ++ const skipModels = new Set(['gray']); ++ const styles = Object.create(null); ++ ++ function applyOptions(obj, options) { ++ options = options || {}; // Detect level if not set manually ++ ++ const scLevel = stdoutColor ? stdoutColor.level : 0; ++ obj.level = options.level === undefined ? scLevel : options.level; ++ obj.enabled = 'enabled' in options ? options.enabled : obj.level > 0; ++ } ++ ++ function Chalk(options) { ++ // We check for this.template here since calling `chalk.constructor()` ++ // by itself will have a `this` of a previously constructed chalk object ++ if (!this || !(this instanceof Chalk) || this.template) { ++ const chalk = {}; ++ applyOptions(chalk, options); ++ ++ chalk.template = function () { ++ const args = [].slice.call(arguments); ++ return chalkTag.apply(null, [chalk.template].concat(args)); ++ }; ++ ++ Object.setPrototypeOf(chalk, Chalk.prototype); ++ Object.setPrototypeOf(chalk.template, chalk); ++ chalk.template.constructor = Chalk; ++ return chalk.template; ++ } ++ ++ applyOptions(this, options); ++ } // Use bright blue on Windows as the normal blue color is illegible ++ ++ ++ if (isSimpleWindowsTerm) { ++ ansiStyles$2.blue.open = '\u001B[94m'; ++ } ++ ++ for (const key of Object.keys(ansiStyles$2)) { ++ ansiStyles$2[key].closeRe = new RegExp(escapeStringRegexp$1(ansiStyles$2[key].close), 'g'); ++ styles[key] = { ++ get() { ++ const codes = ansiStyles$2[key]; ++ return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, key); ++ } ++ ++ }; ++ } ++ ++ styles.visible = { ++ get() { ++ return build.call(this, this._styles || [], true, 'visible'); ++ } ++ ++ }; ++ ansiStyles$2.color.closeRe = new RegExp(escapeStringRegexp$1(ansiStyles$2.color.close), 'g'); ++ ++ for (const model of Object.keys(ansiStyles$2.color.ansi)) { ++ if (skipModels.has(model)) { ++ continue; ++ } ++ ++ styles[model] = { ++ get() { ++ const level = this.level; ++ return function () { ++ const open = ansiStyles$2.color[levelMapping[level]][model].apply(null, arguments); ++ const codes = { ++ open, ++ close: ansiStyles$2.color.close, ++ closeRe: ansiStyles$2.color.closeRe ++ }; ++ return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model); ++ }; ++ } ++ ++ }; ++ } ++ ++ ansiStyles$2.bgColor.closeRe = new RegExp(escapeStringRegexp$1(ansiStyles$2.bgColor.close), 'g'); ++ ++ for (const model of Object.keys(ansiStyles$2.bgColor.ansi)) { ++ if (skipModels.has(model)) { ++ continue; ++ } ++ ++ const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1); ++ styles[bgModel] = { ++ get() { ++ const level = this.level; ++ return function () { ++ const open = ansiStyles$2.bgColor[levelMapping[level]][model].apply(null, arguments); ++ const codes = { ++ open, ++ close: ansiStyles$2.bgColor.close, ++ closeRe: ansiStyles$2.bgColor.closeRe ++ }; ++ return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model); ++ }; ++ } ++ ++ }; ++ } ++ ++ const proto = Object.defineProperties(() => {}, styles); ++ ++ function build(_styles, _empty, key) { ++ const builder = function () { ++ return applyStyle.apply(builder, arguments); ++ }; ++ ++ builder._styles = _styles; ++ builder._empty = _empty; ++ const self = this; ++ Object.defineProperty(builder, 'level', { ++ enumerable: true, ++ ++ get() { ++ return self.level; ++ }, ++ ++ set(level) { ++ self.level = level; ++ } ++ ++ }); ++ Object.defineProperty(builder, 'enabled', { ++ enumerable: true, ++ ++ get() { ++ return self.enabled; ++ }, ++ ++ set(enabled) { ++ self.enabled = enabled; ++ } ++ ++ }); // See below for fix regarding invisible grey/dim combination on Windows ++ ++ builder.hasGrey = this.hasGrey || key === 'gray' || key === 'grey'; // `__proto__` is used because we must return a function, but there is ++ // no way to create a function with a different prototype ++ ++ builder.__proto__ = proto; // eslint-disable-line no-proto ++ ++ return builder; ++ } ++ ++ function applyStyle() { ++ // Support varags, but simply cast to string in case there's only one arg ++ const args = arguments; ++ const argsLen = args.length; ++ let str = String(arguments[0]); ++ ++ if (argsLen === 0) { ++ return ''; ++ } ++ ++ if (argsLen > 1) { ++ // Don't slice `arguments`, it prevents V8 optimizations ++ for (let a = 1; a < argsLen; a++) { ++ str += ' ' + args[a]; ++ } ++ } ++ ++ if (!this.enabled || this.level <= 0 || !str) { ++ return this._empty ? '' : str; ++ } // Turns out that on Windows dimmed gray text becomes invisible in cmd.exe, ++ // see https://github.com/chalk/chalk/issues/58 ++ // If we're on Windows and we're dealing with a gray color, temporarily make 'dim' a noop. ++ ++ ++ const originalDim = ansiStyles$2.dim.open; ++ ++ if (isSimpleWindowsTerm && this.hasGrey) { ++ ansiStyles$2.dim.open = ''; ++ } ++ ++ for (const code of this._styles.slice().reverse()) { ++ // Replace any instances already present with a re-opening code ++ // otherwise only the part of the string until said closing code ++ // will be colored, and the rest will simply be 'plain'. ++ str = code.open + str.replace(code.closeRe, code.open) + code.close; // Close the styling before a linebreak and reopen ++ // after next line to fix a bleed issue on macOS ++ // https://github.com/chalk/chalk/pull/92 ++ ++ str = str.replace(/\r?\n/g, `${code.close}$&${code.open}`); ++ } // Reset the original `dim` if we changed it to work around the Windows dimmed gray issue ++ ++ ++ ansiStyles$2.dim.open = originalDim; ++ return str; ++ } ++ ++ function chalkTag(chalk, strings) { ++ if (!Array.isArray(strings)) { ++ // If chalk() was called by itself or with a string, ++ // return the string itself as a string. ++ return [].slice.call(arguments, 1).join(' '); ++ } ++ ++ const args = [].slice.call(arguments, 2); ++ const parts = [strings.raw[0]]; ++ ++ for (let i = 1; i < strings.length; i++) { ++ parts.push(String(args[i - 1]).replace(/[{}\\]/g, '\\$&')); ++ parts.push(String(strings.raw[i])); ++ } ++ ++ return templates$2(chalk, parts.join('')); ++ } ++ ++ Object.defineProperties(Chalk.prototype, styles); ++ module.exports = Chalk(); // eslint-disable-line new-cap ++ ++ module.exports.supportsColor = stdoutColor; ++ module.exports.default = module.exports; // For TypeScript ++}); ++var chalk_1$1 = chalk$2.supportsColor; ++ ++var lib$1 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ exports.shouldHighlight = shouldHighlight; ++ exports.getChalk = getChalk; ++ exports.default = highlight; ++ ++ var _jsTokens = _interopRequireWildcard(jsTokens); ++ ++ var _esutils = _interopRequireDefault(utils$1); ++ ++ var _chalk = _interopRequireDefault(chalk$2); ++ ++ function _interopRequireDefault(obj) { ++ return obj && obj.__esModule ? obj : { ++ default: obj ++ }; ++ } ++ ++ function _getRequireWildcardCache() { ++ if (typeof WeakMap !== "function") return null; ++ var cache = new WeakMap(); ++ ++ _getRequireWildcardCache = function () { ++ return cache; ++ }; ++ ++ return cache; ++ } ++ ++ function _interopRequireWildcard(obj) { ++ if (obj && obj.__esModule) { ++ return obj; ++ } ++ ++ if (obj === null || typeof obj !== "object" && typeof obj !== "function") { ++ return { ++ default: obj ++ }; ++ } ++ ++ var cache = _getRequireWildcardCache(); ++ ++ if (cache && cache.has(obj)) { ++ return cache.get(obj); ++ } ++ ++ var newObj = {}; ++ var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; ++ ++ for (var key in obj) { ++ if (Object.prototype.hasOwnProperty.call(obj, key)) { ++ var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; ++ ++ if (desc && (desc.get || desc.set)) { ++ Object.defineProperty(newObj, key, desc); ++ } else { ++ newObj[key] = obj[key]; ++ } ++ } ++ } ++ ++ newObj.default = obj; ++ ++ if (cache) { ++ cache.set(obj, newObj); ++ } ++ ++ return newObj; ++ } ++ ++ function getDefs(chalk) { ++ return { ++ keyword: chalk.cyan, ++ capitalized: chalk.yellow, ++ jsx_tag: chalk.yellow, ++ punctuator: chalk.yellow, ++ number: chalk.magenta, ++ string: chalk.green, ++ regex: chalk.magenta, ++ comment: chalk.grey, ++ invalid: chalk.white.bgRed.bold ++ }; ++ } ++ ++ const NEWLINE = /\r\n|[\n\r\u2028\u2029]/; ++ const JSX_TAG = /^[a-z][\w-]*$/i; ++ const BRACKET = /^[()[\]{}]$/; ++ ++ function getTokenType(match) { ++ const [offset, text] = match.slice(-2); ++ const token = (0, _jsTokens.matchToToken)(match); ++ ++ if (token.type === "name") { ++ if (_esutils.default.keyword.isReservedWordES6(token.value)) { ++ return "keyword"; ++ } ++ ++ if (JSX_TAG.test(token.value) && (text[offset - 1] === "<" || text.substr(offset - 2, 2) == " colorize(str)).join("\n"); ++ } else { ++ return args[0]; ++ } ++ }); ++ } ++ ++ function shouldHighlight(options) { ++ return _chalk.default.supportsColor || options.forceColor; ++ } ++ ++ function getChalk(options) { ++ let chalk = _chalk.default; ++ ++ if (options.forceColor) { ++ chalk = new _chalk.default.constructor({ ++ enabled: true, ++ level: 1 ++ }); ++ } ++ ++ return chalk; ++ } ++ ++ function highlight(code, options = {}) { ++ if (shouldHighlight(options)) { ++ const chalk = getChalk(options); ++ const defs = getDefs(chalk); ++ return highlightTokens(defs, code); ++ } else { ++ return code; ++ } ++ } ++}); ++unwrapExports(lib$1); ++var lib_1 = lib$1.shouldHighlight; ++var lib_2 = lib$1.getChalk; ++ ++var lib$2 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ exports.codeFrameColumns = codeFrameColumns; ++ exports.default = _default; ++ ++ var _highlight = _interopRequireWildcard(lib$1); ++ ++ function _getRequireWildcardCache() { ++ if (typeof WeakMap !== "function") return null; ++ var cache = new WeakMap(); ++ ++ _getRequireWildcardCache = function () { ++ return cache; ++ }; ++ ++ return cache; ++ } ++ ++ function _interopRequireWildcard(obj) { ++ if (obj && obj.__esModule) { ++ return obj; ++ } ++ ++ if (obj === null || typeof obj !== "object" && typeof obj !== "function") { ++ return { ++ default: obj ++ }; ++ } ++ ++ var cache = _getRequireWildcardCache(); ++ ++ if (cache && cache.has(obj)) { ++ return cache.get(obj); ++ } ++ ++ var newObj = {}; ++ var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; ++ ++ for (var key in obj) { ++ if (Object.prototype.hasOwnProperty.call(obj, key)) { ++ var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; ++ ++ if (desc && (desc.get || desc.set)) { ++ Object.defineProperty(newObj, key, desc); ++ } else { ++ newObj[key] = obj[key]; ++ } ++ } ++ } ++ ++ newObj.default = obj; ++ ++ if (cache) { ++ cache.set(obj, newObj); ++ } ++ ++ return newObj; ++ } ++ ++ let deprecationWarningShown = false; ++ ++ function getDefs(chalk) { ++ return { ++ gutter: chalk.grey, ++ marker: chalk.red.bold, ++ message: chalk.red.bold ++ }; ++ } ++ ++ const NEWLINE = /\r\n|[\n\r\u2028\u2029]/; ++ ++ function getMarkerLines(loc, source, opts) { ++ const startLoc = Object.assign({ ++ column: 0, ++ line: -1 ++ }, loc.start); ++ const endLoc = Object.assign({}, startLoc, {}, loc.end); ++ const { ++ linesAbove = 2, ++ linesBelow = 3 ++ } = opts || {}; ++ const startLine = startLoc.line; ++ const startColumn = startLoc.column; ++ const endLine = endLoc.line; ++ const endColumn = endLoc.column; ++ let start = Math.max(startLine - (linesAbove + 1), 0); ++ let end = Math.min(source.length, endLine + linesBelow); ++ ++ if (startLine === -1) { ++ start = 0; ++ } ++ ++ if (endLine === -1) { ++ end = source.length; ++ } ++ ++ const lineDiff = endLine - startLine; ++ const markerLines = {}; ++ ++ if (lineDiff) { ++ for (let i = 0; i <= lineDiff; i++) { ++ const lineNumber = i + startLine; ++ ++ if (!startColumn) { ++ markerLines[lineNumber] = true; ++ } else if (i === 0) { ++ const sourceLength = source[lineNumber - 1].length; ++ markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1]; ++ } else if (i === lineDiff) { ++ markerLines[lineNumber] = [0, endColumn]; ++ } else { ++ const sourceLength = source[lineNumber - i].length; ++ markerLines[lineNumber] = [0, sourceLength]; ++ } ++ } ++ } else { ++ if (startColumn === endColumn) { ++ if (startColumn) { ++ markerLines[startLine] = [startColumn, 0]; ++ } else { ++ markerLines[startLine] = true; ++ } ++ } else { ++ markerLines[startLine] = [startColumn, endColumn - startColumn]; ++ } ++ } ++ ++ return { ++ start, ++ end, ++ markerLines ++ }; ++ } ++ ++ function codeFrameColumns(rawLines, loc, opts = {}) { ++ const highlighted = (opts.highlightCode || opts.forceColor) && (0, _highlight.shouldHighlight)(opts); ++ const chalk = (0, _highlight.getChalk)(opts); ++ const defs = getDefs(chalk); ++ ++ const maybeHighlight = (chalkFn, string) => { ++ return highlighted ? chalkFn(string) : string; ++ }; ++ ++ const lines = rawLines.split(NEWLINE); ++ const { ++ start, ++ end, ++ markerLines ++ } = getMarkerLines(loc, lines, opts); ++ const hasColumns = loc.start && typeof loc.start.column === "number"; ++ const numberMaxWidth = String(end).length; ++ const highlightedLines = highlighted ? (0, _highlight.default)(rawLines, opts) : rawLines; ++ let frame = highlightedLines.split(NEWLINE).slice(start, end).map((line, index) => { ++ const number = start + 1 + index; ++ const paddedNumber = ` ${number}`.slice(-numberMaxWidth); ++ const gutter = ` ${paddedNumber} | `; ++ const hasMarker = markerLines[number]; ++ const lastMarkerLine = !markerLines[number + 1]; ++ ++ if (hasMarker) { ++ let markerLine = ""; ++ ++ if (Array.isArray(hasMarker)) { ++ const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " "); ++ const numberOfMarkers = hasMarker[1] || 1; ++ markerLine = ["\n ", maybeHighlight(defs.gutter, gutter.replace(/\d/g, " ")), markerSpacing, maybeHighlight(defs.marker, "^").repeat(numberOfMarkers)].join(""); ++ ++ if (lastMarkerLine && opts.message) { ++ markerLine += " " + maybeHighlight(defs.message, opts.message); ++ } ++ } ++ ++ return [maybeHighlight(defs.marker, ">"), maybeHighlight(defs.gutter, gutter), line, markerLine].join(""); ++ } else { ++ return ` ${maybeHighlight(defs.gutter, gutter)}${line}`; ++ } ++ }).join("\n"); ++ ++ if (opts.message && !hasColumns) { ++ frame = `${" ".repeat(numberMaxWidth + 1)}${opts.message}\n${frame}`; ++ } ++ ++ if (highlighted) { ++ return chalk.reset(frame); ++ } else { ++ return frame; ++ } ++ } ++ ++ function _default(rawLines, lineNumber, colNumber, opts = {}) { ++ if (!deprecationWarningShown) { ++ deprecationWarningShown = true; ++ const message = "Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`."; ++ ++ if (process.emitWarning) { ++ process.emitWarning(message, "DeprecationWarning"); ++ } else { ++ const deprecationError = new Error(message); ++ deprecationError.name = "DeprecationWarning"; ++ console.warn(new Error(message)); ++ } ++ } ++ ++ colNumber = Math.max(colNumber, 0); ++ const location = { ++ start: { ++ column: colNumber, ++ line: lineNumber ++ } ++ }; ++ return codeFrameColumns(rawLines, location, opts); ++ } ++}); ++unwrapExports(lib$2); ++var lib_1$1 = lib$2.codeFrameColumns; ++ ++const { ++ ConfigError: ConfigError$1 ++} = errors; ++const { ++ locStart: locStart$1, ++ locEnd: locEnd$1 ++} = loc; // Use defineProperties()/getOwnPropertyDescriptor() to prevent ++// triggering the parsers getters. ++ ++const ownNames = Object.getOwnPropertyNames; ++const ownDescriptor = Object.getOwnPropertyDescriptor; ++ ++function getParsers(options) { ++ const parsers = {}; ++ ++ for (const plugin of options.plugins) { ++ if (!plugin.parsers) { ++ continue; ++ } ++ ++ for (const name of ownNames(plugin.parsers)) { ++ Object.defineProperty(parsers, name, ownDescriptor(plugin.parsers, name)); ++ } ++ } ++ ++ return parsers; ++} ++ ++function resolveParser(opts, parsers) { ++ parsers = parsers || getParsers(opts); ++ ++ if (typeof opts.parser === "function") { ++ // Custom parser API always works with JavaScript. ++ return { ++ parse: opts.parser, ++ astFormat: "estree", ++ locStart: locStart$1, ++ locEnd: locEnd$1 ++ }; ++ } ++ ++ if (typeof opts.parser === "string") { ++ if (Object.prototype.hasOwnProperty.call(parsers, opts.parser)) { ++ return parsers[opts.parser]; ++ } ++ /* istanbul ignore next */ ++ ++ ++ { ++ try { ++ return { ++ parse: require(path$1.resolve(process.cwd(), opts.parser)), ++ astFormat: "estree", ++ locStart: locStart$1, ++ locEnd: locEnd$1 ++ }; ++ } catch (err) { ++ /* istanbul ignore next */ ++ throw new ConfigError$1(`Couldn't resolve parser "${opts.parser}"`); ++ } ++ } ++ } ++} ++ ++function parse(text, opts) { ++ const parsers = getParsers(opts); // Create a new object {parserName: parseFn}. Uses defineProperty() to only call ++ // the parsers getters when actually calling the parser `parse` function. ++ ++ const parsersForCustomParserApi = Object.keys(parsers).reduce((object, parserName) => Object.defineProperty(object, parserName, { ++ enumerable: true, ++ ++ get() { ++ return parsers[parserName].parse; ++ } ++ ++ }), {}); ++ const parser = resolveParser(opts, parsers); ++ ++ try { ++ if (parser.preprocess) { ++ text = parser.preprocess(text, opts); ++ } ++ ++ return { ++ text, ++ ast: parser.parse(text, parsersForCustomParserApi, opts) ++ }; ++ } catch (error) { ++ const { ++ loc ++ } = error; ++ ++ if (loc) { ++ const codeFrame = lib$2; ++ error.codeFrame = codeFrame.codeFrameColumns(text, loc, { ++ highlightCode: true ++ }); ++ error.message += "\n" + error.codeFrame; ++ throw error; ++ } ++ /* istanbul ignore next */ ++ ++ ++ throw error.stack; ++ } ++} ++ ++var parser = { ++ parse, ++ resolveParser ++}; ++ ++const { ++ UndefinedParserError: UndefinedParserError$1 ++} = errors; ++const { ++ getSupportInfo: getSupportInfo$1 ++} = support; ++const { ++ resolveParser: resolveParser$1 ++} = parser; ++const hiddenDefaults = { ++ astFormat: "estree", ++ printer: {}, ++ originalText: undefined, ++ locStart: null, ++ locEnd: null ++}; // Copy options and fill in default values. ++ ++function normalize$1(options, opts) { ++ opts = opts || {}; ++ const rawOptions = Object.assign({}, options); ++ const supportOptions = getSupportInfo$1({ ++ plugins: options.plugins, ++ showUnreleased: true, ++ showDeprecated: true ++ }).options; ++ const defaults = Object.assign({}, hiddenDefaults, {}, fromPairs_1(supportOptions.filter(optionInfo => optionInfo.default !== undefined).map(option => [option.name, option.default]))); ++ ++ if (!rawOptions.parser) { ++ if (!rawOptions.filepath) { ++ const logger = opts.logger || console; ++ logger.warn("No parser and no filepath given, using 'babel' the parser now " + "but this will throw an error in the future. " + "Please specify a parser or a filepath so one can be inferred."); ++ rawOptions.parser = "babel"; ++ } else { ++ rawOptions.parser = inferParser(rawOptions.filepath, rawOptions.plugins); ++ ++ if (!rawOptions.parser) { ++ throw new UndefinedParserError$1(`No parser could be inferred for file: ${rawOptions.filepath}`); ++ } ++ } ++ } ++ ++ const parser = resolveParser$1(optionsNormalizer.normalizeApiOptions(rawOptions, [supportOptions.find(x => x.name === "parser")], { ++ passThrough: true, ++ logger: false ++ })); ++ rawOptions.astFormat = parser.astFormat; ++ rawOptions.locEnd = parser.locEnd; ++ rawOptions.locStart = parser.locStart; ++ const plugin = getPlugin(rawOptions); ++ rawOptions.printer = plugin.printers[rawOptions.astFormat]; ++ const pluginDefaults = supportOptions.filter(optionInfo => optionInfo.pluginDefaults && optionInfo.pluginDefaults[plugin.name] !== undefined).reduce((reduced, optionInfo) => Object.assign(reduced, { ++ [optionInfo.name]: optionInfo.pluginDefaults[plugin.name] ++ }), {}); ++ const mixedDefaults = Object.assign({}, defaults, {}, pluginDefaults); ++ Object.keys(mixedDefaults).forEach(k => { ++ if (rawOptions[k] == null) { ++ rawOptions[k] = mixedDefaults[k]; ++ } ++ }); ++ ++ if (rawOptions.parser === "json") { ++ rawOptions.trailingComma = "none"; ++ } ++ ++ return optionsNormalizer.normalizeApiOptions(rawOptions, supportOptions, Object.assign({ ++ passThrough: Object.keys(hiddenDefaults) ++ }, opts)); ++} ++ ++function getPlugin(options) { ++ const { ++ astFormat ++ } = options; ++ ++ if (!astFormat) { ++ throw new Error("getPlugin() requires astFormat to be set"); ++ } ++ ++ const printerPlugin = options.plugins.find(plugin => plugin.printers && plugin.printers[astFormat]); ++ ++ if (!printerPlugin) { ++ throw new Error(`Couldn't find plugin for AST format "${astFormat}"`); ++ } ++ ++ return printerPlugin; ++} ++ ++function getInterpreter(filepath) { ++ if (typeof filepath !== "string") { ++ return ""; ++ } ++ ++ let fd; ++ ++ try { ++ fd = fs$2.openSync(filepath, "r"); ++ } catch (err) { ++ // istanbul ignore next ++ return ""; ++ } ++ ++ try { ++ const liner = new readlines(fd); ++ const firstLine = liner.next().toString("utf8"); // #!/bin/env node, #!/usr/bin/env node ++ ++ const m1 = firstLine.match(/^#!\/(?:usr\/)?bin\/env\s+(\S+)/); ++ ++ if (m1) { ++ return m1[1]; ++ } // #!/bin/node, #!/usr/bin/node, #!/usr/local/bin/node ++ ++ ++ const m2 = firstLine.match(/^#!\/(?:usr\/(?:local\/)?)?bin\/(\S+)/); ++ ++ if (m2) { ++ return m2[1]; ++ } ++ ++ return ""; ++ } catch (err) { ++ // There are some weird cases where paths are missing, causing Jest ++ // failures. It's unclear what these correspond to in the real world. ++ return ""; ++ } finally { ++ try { ++ // There are some weird cases where paths are missing, causing Jest ++ // failures. It's unclear what these correspond to in the real world. ++ fs$2.closeSync(fd); ++ } catch (err) {// nop ++ } ++ } ++} ++ ++function inferParser(filepath, plugins) { ++ const filename = path$1.basename(filepath).toLowerCase(); ++ const languages = getSupportInfo$1({ ++ plugins ++ }).languages.filter(language => language.since !== null); // If the file has no extension, we can try to infer the language from the ++ // interpreter in the shebang line, if any; but since this requires FS access, ++ // do it last. ++ ++ let language = languages.find(language => language.extensions && language.extensions.some(extension => filename.endsWith(extension)) || language.filenames && language.filenames.find(name => name.toLowerCase() === filename)); ++ ++ if (!language && !filename.includes(".")) { ++ const interpreter = getInterpreter(filepath); ++ language = languages.find(language => language.interpreters && language.interpreters.includes(interpreter)); ++ } ++ ++ return language && language.parsers[0]; ++} ++ ++var options$1 = { ++ normalize: normalize$1, ++ hiddenDefaults, ++ inferParser ++}; ++ ++function massageAST(ast, options, parent) { ++ if (Array.isArray(ast)) { ++ return ast.map(e => massageAST(e, options, parent)).filter(Boolean); ++ } ++ ++ if (!ast || typeof ast !== "object") { ++ return ast; ++ } ++ ++ const newObj = {}; ++ ++ for (const key of Object.keys(ast)) { ++ if (typeof ast[key] !== "function") { ++ newObj[key] = massageAST(ast[key], options, ast); ++ } ++ } ++ ++ if (options.printer.massageAstNode) { ++ const result = options.printer.massageAstNode(ast, newObj, parent); ++ ++ if (result === null) { ++ return undefined; ++ } ++ ++ if (result) { ++ return result; ++ } ++ } ++ ++ return newObj; ++} ++ ++var massageAst = massageAST; ++ ++/** ++ * @param {Doc[]} parts ++ * @returns Doc ++ */ ++ ++ ++function concat(parts) { ++ // access the internals of a document directly. ++ // if(parts.length === 1) { ++ // // If it's a single document, no need to concat it. ++ // return parts[0]; ++ // } ++ ++ ++ return { ++ type: "concat", ++ parts ++ }; ++} ++/** ++ * @param {Doc} contents ++ * @returns Doc ++ */ ++ ++ ++function indent(contents) { ++ ++ return { ++ type: "indent", ++ contents ++ }; ++} ++/** ++ * @param {number} n ++ * @param {Doc} contents ++ * @returns Doc ++ */ ++ ++ ++function align(n, contents) { ++ ++ return { ++ type: "align", ++ contents, ++ n ++ }; ++} ++/** ++ * @param {Doc} contents ++ * @param {object} [opts] - TBD ??? ++ * @returns Doc ++ */ ++ ++ ++function group(contents, opts) { ++ opts = opts || {}; ++ ++ return { ++ type: "group", ++ id: opts.id, ++ contents, ++ break: !!opts.shouldBreak, ++ expandedStates: opts.expandedStates ++ }; ++} ++/** ++ * @param {Doc} contents ++ * @returns Doc ++ */ ++ ++ ++function dedentToRoot(contents) { ++ return align(-Infinity, contents); ++} ++/** ++ * @param {Doc} contents ++ * @returns Doc ++ */ ++ ++ ++function markAsRoot(contents) { ++ // @ts-ignore - TBD ???: ++ return align({ ++ type: "root" ++ }, contents); ++} ++/** ++ * @param {Doc} contents ++ * @returns Doc ++ */ ++ ++ ++function dedent(contents) { ++ return align(-1, contents); ++} ++/** ++ * @param {Doc[]} states ++ * @param {object} [opts] - TBD ??? ++ * @returns Doc ++ */ ++ ++ ++function conditionalGroup(states, opts) { ++ return group(states[0], Object.assign({}, opts, { ++ expandedStates: states ++ })); ++} ++/** ++ * @param {Doc[]} parts ++ * @returns Doc ++ */ ++ ++ ++function fill(parts) { ++ ++ return { ++ type: "fill", ++ parts ++ }; ++} ++/** ++ * @param {Doc} [breakContents] ++ * @param {Doc} [flatContents] ++ * @param {object} [opts] - TBD ??? ++ * @returns Doc ++ */ ++ ++ ++function ifBreak(breakContents, flatContents, opts) { ++ opts = opts || {}; ++ ++ return { ++ type: "if-break", ++ breakContents, ++ flatContents, ++ groupId: opts.groupId ++ }; ++} ++/** ++ * @param {Doc} contents ++ * @returns Doc ++ */ ++ ++ ++function lineSuffix(contents) { ++ ++ return { ++ type: "line-suffix", ++ contents ++ }; ++} ++ ++const lineSuffixBoundary = { ++ type: "line-suffix-boundary" ++}; ++const breakParent = { ++ type: "break-parent" ++}; ++const trim = { ++ type: "trim" ++}; ++const line = { ++ type: "line" ++}; ++const softline = { ++ type: "line", ++ soft: true ++}; ++const hardline = concat([{ ++ type: "line", ++ hard: true ++}, breakParent]); ++const literalline = concat([{ ++ type: "line", ++ hard: true, ++ literal: true ++}, breakParent]); ++const cursor = { ++ type: "cursor", ++ placeholder: Symbol("cursor") ++}; ++/** ++ * @param {Doc} sep ++ * @param {Doc[]} arr ++ * @returns Doc ++ */ ++ ++function join(sep, arr) { ++ const res = []; ++ ++ for (let i = 0; i < arr.length; i++) { ++ if (i !== 0) { ++ res.push(sep); ++ } ++ ++ res.push(arr[i]); ++ } ++ ++ return concat(res); ++} ++/** ++ * @param {Doc} doc ++ * @param {number} size ++ * @param {number} tabWidth ++ */ ++ ++ ++function addAlignmentToDoc(doc, size, tabWidth) { ++ let aligned = doc; ++ ++ if (size > 0) { ++ // Use indent to add tabs for all the levels of tabs we need ++ for (let i = 0; i < Math.floor(size / tabWidth); ++i) { ++ aligned = indent(aligned); ++ } // Use align for all the spaces that are needed ++ ++ ++ aligned = align(size % tabWidth, aligned); // size is absolute from 0 and not relative to the current ++ // indentation, so we use -Infinity to reset the indentation to 0 ++ ++ aligned = align(-Infinity, aligned); ++ } ++ ++ return aligned; ++} ++ ++var docBuilders = { ++ concat, ++ join, ++ line, ++ softline, ++ hardline, ++ literalline, ++ group, ++ conditionalGroup, ++ fill, ++ lineSuffix, ++ lineSuffixBoundary, ++ cursor, ++ breakParent, ++ ifBreak, ++ trim, ++ indent, ++ align, ++ addAlignmentToDoc, ++ markAsRoot, ++ dedentToRoot, ++ dedent ++}; ++ ++var ansiRegex = ({ ++ onlyFirst = false ++} = {}) => { ++ const pattern = ['[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)', '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))'].join('|'); ++ return new RegExp(pattern, onlyFirst ? undefined : 'g'); ++}; ++ ++var stripAnsi = string => typeof string === 'string' ? string.replace(ansiRegex(), '') : string; ++ ++/* eslint-disable yoda */ ++ ++const isFullwidthCodePoint = codePoint => { ++ if (Number.isNaN(codePoint)) { ++ return false; ++ } // Code points are derived from: ++ // http://www.unix.org/Public/UNIDATA/EastAsianWidth.txt ++ ++ ++ if (codePoint >= 0x1100 && (codePoint <= 0x115F || // Hangul Jamo ++ codePoint === 0x2329 || // LEFT-POINTING ANGLE BRACKET ++ codePoint === 0x232A || // RIGHT-POINTING ANGLE BRACKET ++ // CJK Radicals Supplement .. Enclosed CJK Letters and Months ++ 0x2E80 <= codePoint && codePoint <= 0x3247 && codePoint !== 0x303F || // Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A ++ 0x3250 <= codePoint && codePoint <= 0x4DBF || // CJK Unified Ideographs .. Yi Radicals ++ 0x4E00 <= codePoint && codePoint <= 0xA4C6 || // Hangul Jamo Extended-A ++ 0xA960 <= codePoint && codePoint <= 0xA97C || // Hangul Syllables ++ 0xAC00 <= codePoint && codePoint <= 0xD7A3 || // CJK Compatibility Ideographs ++ 0xF900 <= codePoint && codePoint <= 0xFAFF || // Vertical Forms ++ 0xFE10 <= codePoint && codePoint <= 0xFE19 || // CJK Compatibility Forms .. Small Form Variants ++ 0xFE30 <= codePoint && codePoint <= 0xFE6B || // Halfwidth and Fullwidth Forms ++ 0xFF01 <= codePoint && codePoint <= 0xFF60 || 0xFFE0 <= codePoint && codePoint <= 0xFFE6 || // Kana Supplement ++ 0x1B000 <= codePoint && codePoint <= 0x1B001 || // Enclosed Ideographic Supplement ++ 0x1F200 <= codePoint && codePoint <= 0x1F251 || // CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane ++ 0x20000 <= codePoint && codePoint <= 0x3FFFD)) { ++ return true; ++ } ++ ++ return false; ++}; ++ ++var isFullwidthCodePoint_1 = isFullwidthCodePoint; ++var default_1$1 = isFullwidthCodePoint; ++isFullwidthCodePoint_1.default = default_1$1; ++ ++var emojiRegex = function () { ++ // https://mths.be/emoji ++ return /\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62(?:\uDB40\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDB40\uDC73\uDB40\uDC63\uDB40\uDC74|\uDB40\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F|\uD83D\uDC68(?:\uD83C\uDFFC\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFB|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFE])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFD])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFC])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83D\uDC68|(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D[\uDC66\uDC67])|[\u2695\u2696\u2708]\uFE0F|\uD83D[\uDC66\uDC67]|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|(?:\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708])\uFE0F|\uD83C\uDFFB\u200D(?:\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C[\uDFFB-\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC69)\uD83C\uDFFB|\uD83E\uDDD1(?:\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1(?:\uD83C[\uDFFB-\uDFFF])|\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1)|(?:\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB-\uDFFE])|(?:\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC69)(?:\uD83C[\uDFFB\uDFFC])|\uD83D\uDC69(?:\uD83C\uDFFE\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFD\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFD-\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFB\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFC-\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|(?:\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC69)(?:\uD83C[\uDFFB-\uDFFD])|\uD83D\uDC69\u200D\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D[\uDC66\uDC67])|(?:\uD83D\uDC41\uFE0F\u200D\uD83D\uDDE8|\uD83D\uDC69(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])|(?:(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)\uFE0F|\uD83D\uDC6F|\uD83E[\uDD3C\uDDDE\uDDDF])\u200D[\u2640\u2642]|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD6-\uDDDD])(?:(?:\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|\u200D[\u2640\u2642])|\uD83C\uDFF4\u200D\u2620)\uFE0F|\uD83D\uDC69\u200D\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|\uD83C\uDFF3\uFE0F\u200D\uD83C\uDF08|\uD83D\uDC15\u200D\uD83E\uDDBA|\uD83D\uDC69\u200D\uD83D\uDC66|\uD83D\uDC69\u200D\uD83D\uDC67|\uD83C\uDDFD\uD83C\uDDF0|\uD83C\uDDF4\uD83C\uDDF2|\uD83C\uDDF6\uD83C\uDDE6|[#\*0-9]\uFE0F\u20E3|\uD83C\uDDE7(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF])|\uD83C\uDDF9(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF])|\uD83C\uDDEA(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA])|\uD83E\uDDD1(?:\uD83C[\uDFFB-\uDFFF])|\uD83C\uDDF7(?:\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC])|\uD83D\uDC69(?:\uD83C[\uDFFB-\uDFFF])|\uD83C\uDDF2(?:\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF])|\uD83C\uDDE6(?:\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF])|\uD83C\uDDF0(?:\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF])|\uD83C\uDDED(?:\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA])|\uD83C\uDDE9(?:\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF])|\uD83C\uDDFE(?:\uD83C[\uDDEA\uDDF9])|\uD83C\uDDEC(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE])|\uD83C\uDDF8(?:\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF])|\uD83C\uDDEB(?:\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7])|\uD83C\uDDF5(?:\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE])|\uD83C\uDDFB(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA])|\uD83C\uDDF3(?:\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF])|\uD83C\uDDE8(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF])|\uD83C\uDDF1(?:\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE])|\uD83C\uDDFF(?:\uD83C[\uDDE6\uDDF2\uDDFC])|\uD83C\uDDFC(?:\uD83C[\uDDEB\uDDF8])|\uD83C\uDDFA(?:\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF])|\uD83C\uDDEE(?:\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9])|\uD83C\uDDEF(?:\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5])|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u261D\u270A-\u270D]|\uD83C[\uDF85\uDFC2\uDFC7]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC70\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDCAA\uDD74\uDD7A\uDD90\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC]|\uD83E[\uDD0F\uDD18-\uDD1C\uDD1E\uDD1F\uDD30-\uDD36\uDDB5\uDDB6\uDDBB\uDDD2-\uDDD5])(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u231A\u231B\u23E9-\u23EC\u23F0\u23F3\u25FD\u25FE\u2614\u2615\u2648-\u2653\u267F\u2693\u26A1\u26AA\u26AB\u26BD\u26BE\u26C4\u26C5\u26CE\u26D4\u26EA\u26F2\u26F3\u26F5\u26FA\u26FD\u2705\u270A\u270B\u2728\u274C\u274E\u2753-\u2755\u2757\u2795-\u2797\u27B0\u27BF\u2B1B\u2B1C\u2B50\u2B55]|\uD83C[\uDC04\uDCCF\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF93\uDFA0-\uDFCA\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF4\uDFF8-\uDFFF]|\uD83D[\uDC00-\uDC3E\uDC40\uDC42-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDD7A\uDD95\uDD96\uDDA4\uDDFB-\uDE4F\uDE80-\uDEC5\uDECC\uDED0-\uDED2\uDED5\uDEEB\uDEEC\uDEF4-\uDEFA\uDFE0-\uDFEB]|\uD83E[\uDD0D-\uDD3A\uDD3C-\uDD45\uDD47-\uDD71\uDD73-\uDD76\uDD7A-\uDDA2\uDDA5-\uDDAA\uDDAE-\uDDCA\uDDCD-\uDDFF\uDE70-\uDE73\uDE78-\uDE7A\uDE80-\uDE82\uDE90-\uDE95])|(?:[#\*0-9\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23E9-\u23F3\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB-\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u261D\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692-\u2697\u2699\u269B\u269C\u26A0\u26A1\u26AA\u26AB\u26B0\u26B1\u26BD\u26BE\u26C4\u26C5\u26C8\u26CE\u26CF\u26D1\u26D3\u26D4\u26E9\u26EA\u26F0-\u26F5\u26F7-\u26FA\u26FD\u2702\u2705\u2708-\u270D\u270F\u2712\u2714\u2716\u271D\u2721\u2728\u2733\u2734\u2744\u2747\u274C\u274E\u2753-\u2755\u2757\u2763\u2764\u2795-\u2797\u27A1\u27B0\u27BF\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B50\u2B55\u3030\u303D\u3297\u3299]|\uD83C[\uDC04\uDCCF\uDD70\uDD71\uDD7E\uDD7F\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE02\uDE1A\uDE2F\uDE32-\uDE3A\uDE50\uDE51\uDF00-\uDF21\uDF24-\uDF93\uDF96\uDF97\uDF99-\uDF9B\uDF9E-\uDFF0\uDFF3-\uDFF5\uDFF7-\uDFFF]|\uD83D[\uDC00-\uDCFD\uDCFF-\uDD3D\uDD49-\uDD4E\uDD50-\uDD67\uDD6F\uDD70\uDD73-\uDD7A\uDD87\uDD8A-\uDD8D\uDD90\uDD95\uDD96\uDDA4\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA-\uDE4F\uDE80-\uDEC5\uDECB-\uDED2\uDED5\uDEE0-\uDEE5\uDEE9\uDEEB\uDEEC\uDEF0\uDEF3-\uDEFA\uDFE0-\uDFEB]|\uD83E[\uDD0D-\uDD3A\uDD3C-\uDD45\uDD47-\uDD71\uDD73-\uDD76\uDD7A-\uDDA2\uDDA5-\uDDAA\uDDAE-\uDDCA\uDDCD-\uDDFF\uDE70-\uDE73\uDE78-\uDE7A\uDE80-\uDE82\uDE90-\uDE95])\uFE0F|(?:[\u261D\u26F9\u270A-\u270D]|\uD83C[\uDF85\uDFC2-\uDFC4\uDFC7\uDFCA-\uDFCC]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66-\uDC78\uDC7C\uDC81-\uDC83\uDC85-\uDC87\uDC8F\uDC91\uDCAA\uDD74\uDD75\uDD7A\uDD90\uDD95\uDD96\uDE45-\uDE47\uDE4B-\uDE4F\uDEA3\uDEB4-\uDEB6\uDEC0\uDECC]|\uD83E[\uDD0F\uDD18-\uDD1F\uDD26\uDD30-\uDD39\uDD3C-\uDD3E\uDDB5\uDDB6\uDDB8\uDDB9\uDDBB\uDDCD-\uDDCF\uDDD1-\uDDDD])/g; ++}; ++ ++const stringWidth = string => { ++ string = string.replace(emojiRegex(), ' '); ++ ++ if (typeof string !== 'string' || string.length === 0) { ++ return 0; ++ } ++ ++ string = stripAnsi(string); ++ let width = 0; ++ ++ for (let i = 0; i < string.length; i++) { ++ const code = string.codePointAt(i); // Ignore control characters ++ ++ if (code <= 0x1F || code >= 0x7F && code <= 0x9F) { ++ continue; ++ } // Ignore combining characters ++ ++ ++ if (code >= 0x300 && code <= 0x36F) { ++ continue; ++ } // Surrogates ++ ++ ++ if (code > 0xFFFF) { ++ i++; ++ } ++ ++ width += isFullwidthCodePoint_1(code) ? 2 : 1; ++ } ++ ++ return width; ++}; ++ ++var stringWidth_1 = stringWidth; // TODO: remove this in the next major version ++ ++var default_1$2 = stringWidth; ++stringWidth_1.default = default_1$2; ++ ++const matchOperatorsRegex = /[|\\{}()[\]^$+*?.-]/g; ++ ++var escapeStringRegexp$2 = string => { ++ if (typeof string !== 'string') { ++ throw new TypeError('Expected a string'); ++ } ++ ++ return string.replace(matchOperatorsRegex, '\\$&'); ++}; ++ ++const notAsciiRegex = /[^\x20-\x7F]/; ++ ++function getPenultimate(arr) { ++ if (arr.length > 1) { ++ return arr[arr.length - 2]; ++ } ++ ++ return null; ++} ++/** ++ * @typedef {{backwards?: boolean}} SkipOptions ++ */ ++ ++/** ++ * @param {string | RegExp} chars ++ * @returns {(text: string, index: number | false, opts?: SkipOptions) => number | false} ++ */ ++ ++ ++function skip(chars) { ++ return (text, index, opts) => { ++ const backwards = opts && opts.backwards; // Allow `skip` functions to be threaded together without having ++ // to check for failures (did someone say monads?). ++ ++ if (index === false) { ++ return false; ++ } ++ ++ const { ++ length ++ } = text; ++ let cursor = index; ++ ++ while (cursor >= 0 && cursor < length) { ++ const c = text.charAt(cursor); ++ ++ if (chars instanceof RegExp) { ++ if (!chars.test(c)) { ++ return cursor; ++ } ++ } else if (!chars.includes(c)) { ++ return cursor; ++ } ++ ++ backwards ? cursor-- : cursor++; ++ } ++ ++ if (cursor === -1 || cursor === length) { ++ // If we reached the beginning or end of the file, return the ++ // out-of-bounds cursor. It's up to the caller to handle this ++ // correctly. We don't want to indicate `false` though if it ++ // actually skipped valid characters. ++ return cursor; ++ } ++ ++ return false; ++ }; ++} ++/** ++ * @type {(text: string, index: number | false, opts?: SkipOptions) => number | false} ++ */ ++ ++ ++const skipWhitespace = skip(/\s/); ++/** ++ * @type {(text: string, index: number | false, opts?: SkipOptions) => number | false} ++ */ ++ ++const skipSpaces = skip(" \t"); ++/** ++ * @type {(text: string, index: number | false, opts?: SkipOptions) => number | false} ++ */ ++ ++const skipToLineEnd = skip(",; \t"); ++/** ++ * @type {(text: string, index: number | false, opts?: SkipOptions) => number | false} ++ */ ++ ++const skipEverythingButNewLine = skip(/[^\r\n]/); ++/** ++ * @param {string} text ++ * @param {number | false} index ++ * @returns {number | false} ++ */ ++ ++function skipInlineComment(text, index) { ++ if (index === false) { ++ return false; ++ } ++ ++ if (text.charAt(index) === "/" && text.charAt(index + 1) === "*") { ++ for (let i = index + 2; i < text.length; ++i) { ++ if (text.charAt(i) === "*" && text.charAt(i + 1) === "/") { ++ return i + 2; ++ } ++ } ++ } ++ ++ return index; ++} ++/** ++ * @param {string} text ++ * @param {number | false} index ++ * @returns {number | false} ++ */ ++ ++ ++function skipTrailingComment(text, index) { ++ if (index === false) { ++ return false; ++ } ++ ++ if (text.charAt(index) === "/" && text.charAt(index + 1) === "/") { ++ return skipEverythingButNewLine(text, index); ++ } ++ ++ return index; ++} // This one doesn't use the above helper function because it wants to ++// test \r\n in order and `skip` doesn't support ordering and we only ++// want to skip one newline. It's simple to implement. ++ ++/** ++ * @param {string} text ++ * @param {number | false} index ++ * @param {SkipOptions=} opts ++ * @returns {number | false} ++ */ ++ ++ ++function skipNewline(text, index, opts) { ++ const backwards = opts && opts.backwards; ++ ++ if (index === false) { ++ return false; ++ } ++ ++ const atIndex = text.charAt(index); ++ ++ if (backwards) { ++ if (text.charAt(index - 1) === "\r" && atIndex === "\n") { ++ return index - 2; ++ } ++ ++ if (atIndex === "\n" || atIndex === "\r" || atIndex === "\u2028" || atIndex === "\u2029") { ++ return index - 1; ++ } ++ } else { ++ if (atIndex === "\r" && text.charAt(index + 1) === "\n") { ++ return index + 2; ++ } ++ ++ if (atIndex === "\n" || atIndex === "\r" || atIndex === "\u2028" || atIndex === "\u2029") { ++ return index + 1; ++ } ++ } ++ ++ return index; ++} ++/** ++ * @param {string} text ++ * @param {number} index ++ * @param {SkipOptions=} opts ++ * @returns {boolean} ++ */ ++ ++ ++function hasNewline(text, index, opts) { ++ opts = opts || {}; ++ const idx = skipSpaces(text, opts.backwards ? index - 1 : index, opts); ++ const idx2 = skipNewline(text, idx, opts); ++ return idx !== idx2; ++} ++/** ++ * @param {string} text ++ * @param {number} start ++ * @param {number} end ++ * @returns {boolean} ++ */ ++ ++ ++function hasNewlineInRange(text, start, end) { ++ for (let i = start; i < end; ++i) { ++ if (text.charAt(i) === "\n") { ++ return true; ++ } ++ } ++ ++ return false; ++} // Note: this function doesn't ignore leading comments unlike isNextLineEmpty ++ ++/** ++ * @template N ++ * @param {string} text ++ * @param {N} node ++ * @param {(node: N) => number} locStart ++ */ ++ ++ ++function isPreviousLineEmpty(text, node, locStart) { ++ /** @type {number | false} */ ++ let idx = locStart(node) - 1; ++ idx = skipSpaces(text, idx, { ++ backwards: true ++ }); ++ idx = skipNewline(text, idx, { ++ backwards: true ++ }); ++ idx = skipSpaces(text, idx, { ++ backwards: true ++ }); ++ const idx2 = skipNewline(text, idx, { ++ backwards: true ++ }); ++ return idx !== idx2; ++} ++/** ++ * @param {string} text ++ * @param {number} index ++ * @returns {boolean} ++ */ ++ ++ ++function isNextLineEmptyAfterIndex(text, index) { ++ /** @type {number | false} */ ++ let oldIdx = null; ++ /** @type {number | false} */ ++ ++ let idx = index; ++ ++ while (idx !== oldIdx) { ++ // We need to skip all the potential trailing inline comments ++ oldIdx = idx; ++ idx = skipToLineEnd(text, idx); ++ idx = skipInlineComment(text, idx); ++ idx = skipSpaces(text, idx); ++ } ++ ++ idx = skipTrailingComment(text, idx); ++ idx = skipNewline(text, idx); ++ return idx !== false && hasNewline(text, idx); ++} ++/** ++ * @template N ++ * @param {string} text ++ * @param {N} node ++ * @param {(node: N) => number} locEnd ++ * @returns {boolean} ++ */ ++ ++ ++function isNextLineEmpty(text, node, locEnd) { ++ return isNextLineEmptyAfterIndex(text, locEnd(node)); ++} ++/** ++ * @param {string} text ++ * @param {number} idx ++ * @returns {number | false} ++ */ ++ ++ ++function getNextNonSpaceNonCommentCharacterIndexWithStartIndex(text, idx) { ++ /** @type {number | false} */ ++ let oldIdx = null; ++ /** @type {number | false} */ ++ ++ let nextIdx = idx; ++ ++ while (nextIdx !== oldIdx) { ++ oldIdx = nextIdx; ++ nextIdx = skipSpaces(text, nextIdx); ++ nextIdx = skipInlineComment(text, nextIdx); ++ nextIdx = skipTrailingComment(text, nextIdx); ++ nextIdx = skipNewline(text, nextIdx); ++ } ++ ++ return nextIdx; ++} ++/** ++ * @template N ++ * @param {string} text ++ * @param {N} node ++ * @param {(node: N) => number} locEnd ++ * @returns {number | false} ++ */ ++ ++ ++function getNextNonSpaceNonCommentCharacterIndex(text, node, locEnd) { ++ return getNextNonSpaceNonCommentCharacterIndexWithStartIndex(text, locEnd(node)); ++} ++/** ++ * @template N ++ * @param {string} text ++ * @param {N} node ++ * @param {(node: N) => number} locEnd ++ * @returns {string} ++ */ ++ ++ ++function getNextNonSpaceNonCommentCharacter(text, node, locEnd) { ++ return text.charAt( // @ts-ignore => TBD: can return false, should we define a fallback? ++ getNextNonSpaceNonCommentCharacterIndex(text, node, locEnd)); ++} ++/** ++ * @param {string} text ++ * @param {number} index ++ * @param {SkipOptions=} opts ++ * @returns {boolean} ++ */ ++ ++ ++function hasSpaces(text, index, opts) { ++ opts = opts || {}; ++ const idx = skipSpaces(text, opts.backwards ? index - 1 : index, opts); ++ return idx !== index; ++} ++/** ++ * @param {{range?: [number, number], start?: number}} node ++ * @param {number} index ++ */ ++ ++ ++function setLocStart(node, index) { ++ if (node.range) { ++ node.range[0] = index; ++ } else { ++ node.start = index; ++ } ++} ++/** ++ * @param {{range?: [number, number], end?: number}} node ++ * @param {number} index ++ */ ++ ++ ++function setLocEnd(node, index) { ++ if (node.range) { ++ node.range[1] = index; ++ } else { ++ node.end = index; ++ } ++} ++ ++const PRECEDENCE = {}; ++[["|>"], ["??"], ["||"], ["&&"], ["|"], ["^"], ["&"], ["==", "===", "!=", "!=="], ["<", ">", "<=", ">=", "in", "instanceof"], [">>", "<<", ">>>"], ["+", "-"], ["*", "/", "%"], ["**"]].forEach((tier, i) => { ++ tier.forEach(op => { ++ PRECEDENCE[op] = i; ++ }); ++}); ++ ++function getPrecedence(op) { ++ return PRECEDENCE[op]; ++} ++ ++const equalityOperators = { ++ "==": true, ++ "!=": true, ++ "===": true, ++ "!==": true ++}; ++const multiplicativeOperators = { ++ "*": true, ++ "/": true, ++ "%": true ++}; ++const bitshiftOperators = { ++ ">>": true, ++ ">>>": true, ++ "<<": true ++}; ++ ++function shouldFlatten(parentOp, nodeOp) { ++ if (getPrecedence(nodeOp) !== getPrecedence(parentOp)) { ++ return false; ++ } // ** is right-associative ++ // x ** y ** z --> x ** (y ** z) ++ ++ ++ if (parentOp === "**") { ++ return false; ++ } // x == y == z --> (x == y) == z ++ ++ ++ if (equalityOperators[parentOp] && equalityOperators[nodeOp]) { ++ return false; ++ } // x * y % z --> (x * y) % z ++ ++ ++ if (nodeOp === "%" && multiplicativeOperators[parentOp] || parentOp === "%" && multiplicativeOperators[nodeOp]) { ++ return false; ++ } // x * y / z --> (x * y) / z ++ // x / y * z --> (x / y) * z ++ ++ ++ if (nodeOp !== parentOp && multiplicativeOperators[nodeOp] && multiplicativeOperators[parentOp]) { ++ return false; ++ } // x << y << z --> (x << y) << z ++ ++ ++ if (bitshiftOperators[parentOp] && bitshiftOperators[nodeOp]) { ++ return false; ++ } ++ ++ return true; ++} ++ ++function isBitwiseOperator(operator) { ++ return !!bitshiftOperators[operator] || operator === "|" || operator === "^" || operator === "&"; ++} // Tests if an expression starts with `{`, or (if forbidFunctionClassAndDoExpr ++// holds) `function`, `class`, or `do {}`. Will be overzealous if there's ++// already necessary grouping parentheses. ++ ++ ++function startsWithNoLookaheadToken(node, forbidFunctionClassAndDoExpr) { ++ node = getLeftMost(node); ++ ++ switch (node.type) { ++ case "FunctionExpression": ++ case "ClassExpression": ++ case "DoExpression": ++ return forbidFunctionClassAndDoExpr; ++ ++ case "ObjectExpression": ++ return true; ++ ++ case "MemberExpression": ++ case "OptionalMemberExpression": ++ return startsWithNoLookaheadToken(node.object, forbidFunctionClassAndDoExpr); ++ ++ case "TaggedTemplateExpression": ++ if (node.tag.type === "FunctionExpression") { ++ // IIFEs are always already parenthesized ++ return false; ++ } ++ ++ return startsWithNoLookaheadToken(node.tag, forbidFunctionClassAndDoExpr); ++ ++ case "CallExpression": ++ case "OptionalCallExpression": ++ if (node.callee.type === "FunctionExpression") { ++ // IIFEs are always already parenthesized ++ return false; ++ } ++ ++ return startsWithNoLookaheadToken(node.callee, forbidFunctionClassAndDoExpr); ++ ++ case "ConditionalExpression": ++ return startsWithNoLookaheadToken(node.test, forbidFunctionClassAndDoExpr); ++ ++ case "UpdateExpression": ++ return !node.prefix && startsWithNoLookaheadToken(node.argument, forbidFunctionClassAndDoExpr); ++ ++ case "BindExpression": ++ return node.object && startsWithNoLookaheadToken(node.object, forbidFunctionClassAndDoExpr); ++ ++ case "SequenceExpression": ++ return startsWithNoLookaheadToken(node.expressions[0], forbidFunctionClassAndDoExpr); ++ ++ case "TSAsExpression": ++ return startsWithNoLookaheadToken(node.expression, forbidFunctionClassAndDoExpr); ++ ++ default: ++ return false; ++ } ++} ++ ++function getLeftMost(node) { ++ if (node.left) { ++ return getLeftMost(node.left); ++ } ++ ++ return node; ++} ++/** ++ * @param {string} value ++ * @param {number} tabWidth ++ * @param {number=} startIndex ++ * @returns {number} ++ */ ++ ++ ++function getAlignmentSize(value, tabWidth, startIndex) { ++ startIndex = startIndex || 0; ++ let size = 0; ++ ++ for (let i = startIndex; i < value.length; ++i) { ++ if (value[i] === "\t") { ++ // Tabs behave in a way that they are aligned to the nearest ++ // multiple of tabWidth: ++ // 0 -> 4, 1 -> 4, 2 -> 4, 3 -> 4 ++ // 4 -> 8, 5 -> 8, 6 -> 8, 7 -> 8 ... ++ size = size + tabWidth - size % tabWidth; ++ } else { ++ size++; ++ } ++ } ++ ++ return size; ++} ++/** ++ * @param {string} value ++ * @param {number} tabWidth ++ * @returns {number} ++ */ ++ ++ ++function getIndentSize(value, tabWidth) { ++ const lastNewlineIndex = value.lastIndexOf("\n"); ++ ++ if (lastNewlineIndex === -1) { ++ return 0; ++ } ++ ++ return getAlignmentSize( // All the leading whitespaces ++ value.slice(lastNewlineIndex + 1).match(/^[ \t]*/)[0], tabWidth); ++} ++/** ++ * @typedef {'"' | "'"} Quote ++ */ ++ ++/** ++ * ++ * @param {string} raw ++ * @param {Quote} preferredQuote ++ * @returns {Quote} ++ */ ++ ++ ++function getPreferredQuote(raw, preferredQuote) { ++ // `rawContent` is the string exactly like it appeared in the input source ++ // code, without its enclosing quotes. ++ const rawContent = raw.slice(1, -1); ++ /** @type {{ quote: '"', regex: RegExp }} */ ++ ++ const double = { ++ quote: '"', ++ regex: /"/g ++ }; ++ /** @type {{ quote: "'", regex: RegExp }} */ ++ ++ const single = { ++ quote: "'", ++ regex: /'/g ++ }; ++ const preferred = preferredQuote === "'" ? single : double; ++ const alternate = preferred === single ? double : single; ++ let result = preferred.quote; // If `rawContent` contains at least one of the quote preferred for enclosing ++ // the string, we might want to enclose with the alternate quote instead, to ++ // minimize the number of escaped quotes. ++ ++ if (rawContent.includes(preferred.quote) || rawContent.includes(alternate.quote)) { ++ const numPreferredQuotes = (rawContent.match(preferred.regex) || []).length; ++ const numAlternateQuotes = (rawContent.match(alternate.regex) || []).length; ++ result = numPreferredQuotes > numAlternateQuotes ? alternate.quote : preferred.quote; ++ } ++ ++ return result; ++} ++ ++function printString(raw, options, isDirectiveLiteral) { ++ // `rawContent` is the string exactly like it appeared in the input source ++ // code, without its enclosing quotes. ++ const rawContent = raw.slice(1, -1); // Check for the alternate quote, to determine if we're allowed to swap ++ // the quotes on a DirectiveLiteral. ++ ++ const canChangeDirectiveQuotes = !rawContent.includes('"') && !rawContent.includes("'"); ++ /** @type {Quote} */ ++ ++ const enclosingQuote = options.parser === "json" ? '"' : options.__isInHtmlAttribute ? "'" : getPreferredQuote(raw, options.singleQuote ? "'" : '"'); // Directives are exact code unit sequences, which means that you can't ++ // change the escape sequences they use. ++ // See https://github.com/prettier/prettier/issues/1555 ++ // and https://tc39.github.io/ecma262/#directive-prologue ++ ++ if (isDirectiveLiteral) { ++ if (canChangeDirectiveQuotes) { ++ return enclosingQuote + rawContent + enclosingQuote; ++ } ++ ++ return raw; ++ } // It might sound unnecessary to use `makeString` even if the string already ++ // is enclosed with `enclosingQuote`, but it isn't. The string could contain ++ // unnecessary escapes (such as in `"\'"`). Always using `makeString` makes ++ // sure that we consistently output the minimum amount of escaped quotes. ++ ++ ++ return makeString(rawContent, enclosingQuote, !(options.parser === "css" || options.parser === "less" || options.parser === "scss" || options.embeddedInHtml)); ++} ++/** ++ * @param {string} rawContent ++ * @param {Quote} enclosingQuote ++ * @param {boolean=} unescapeUnnecessaryEscapes ++ * @returns {string} ++ */ ++ ++ ++function makeString(rawContent, enclosingQuote, unescapeUnnecessaryEscapes) { ++ const otherQuote = enclosingQuote === '"' ? "'" : '"'; // Matches _any_ escape and unescaped quotes (both single and double). ++ ++ const regex = /\\([\s\S])|(['"])/g; // Escape and unescape single and double quotes as needed to be able to ++ // enclose `rawContent` with `enclosingQuote`. ++ ++ const newContent = rawContent.replace(regex, (match, escaped, quote) => { ++ // If we matched an escape, and the escaped character is a quote of the ++ // other type than we intend to enclose the string with, there's no need for ++ // it to be escaped, so return it _without_ the backslash. ++ if (escaped === otherQuote) { ++ return escaped; ++ } // If we matched an unescaped quote and it is of the _same_ type as we ++ // intend to enclose the string with, it must be escaped, so return it with ++ // a backslash. ++ ++ ++ if (quote === enclosingQuote) { ++ return "\\" + quote; ++ } ++ ++ if (quote) { ++ return quote; ++ } // Unescape any unnecessarily escaped character. ++ // Adapted from https://github.com/eslint/eslint/blob/de0b4ad7bd820ade41b1f606008bea68683dc11a/lib/rules/no-useless-escape.js#L27 ++ ++ ++ return unescapeUnnecessaryEscapes && /^[^\\nrvtbfux\r\n\u2028\u2029"'0-7]$/.test(escaped) ? escaped : "\\" + escaped; ++ }); ++ return enclosingQuote + newContent + enclosingQuote; ++} ++ ++function printNumber(rawNumber) { ++ return rawNumber.toLowerCase() // Remove unnecessary plus and zeroes from scientific notation. ++ .replace(/^([+-]?[\d.]+e)(?:\+|(-))?0*(\d)/, "$1$2$3") // Remove unnecessary scientific notation (1e0). ++ .replace(/^([+-]?[\d.]+)e[+-]?0+$/, "$1") // Make sure numbers always start with a digit. ++ .replace(/^([+-])?\./, "$10.") // Remove extraneous trailing decimal zeroes. ++ .replace(/(\.\d+?)0+(?=e|$)/, "$1") // Remove trailing dot. ++ .replace(/\.(?=e|$)/, ""); ++} ++/** ++ * @param {string} str ++ * @param {string} target ++ * @returns {number} ++ */ ++ ++ ++function getMaxContinuousCount(str, target) { ++ const results = str.match(new RegExp(`(${escapeStringRegexp$2(target)})+`, "g")); ++ ++ if (results === null) { ++ return 0; ++ } ++ ++ return results.reduce((maxCount, result) => Math.max(maxCount, result.length / target.length), 0); ++} ++ ++function getMinNotPresentContinuousCount(str, target) { ++ const matches = str.match(new RegExp(`(${escapeStringRegexp$2(target)})+`, "g")); ++ ++ if (matches === null) { ++ return 0; ++ } ++ ++ const countPresent = new Map(); ++ let max = 0; ++ ++ for (const match of matches) { ++ const count = match.length / target.length; ++ countPresent.set(count, true); ++ ++ if (count > max) { ++ max = count; ++ } ++ } ++ ++ for (let i = 1; i < max; i++) { ++ if (!countPresent.get(i)) { ++ return i; ++ } ++ } ++ ++ return max + 1; ++} ++/** ++ * @param {string} text ++ * @returns {number} ++ */ ++ ++ ++function getStringWidth(text) { ++ if (!text) { ++ return 0; ++ } // shortcut to avoid needless string `RegExp`s, replacements, and allocations within `string-width` ++ ++ ++ if (!notAsciiRegex.test(text)) { ++ return text.length; ++ } ++ ++ return stringWidth_1(text); ++} ++ ++function hasIgnoreComment(path) { ++ const node = path.getValue(); ++ return hasNodeIgnoreComment(node); ++} ++ ++function hasNodeIgnoreComment(node) { ++ return node && (node.comments && node.comments.length > 0 && node.comments.some(comment => isNodeIgnoreComment(comment) && !comment.unignore) || node.prettierIgnore); ++} ++ ++function isNodeIgnoreComment(comment) { ++ return comment.value.trim() === "prettier-ignore"; ++} ++ ++function addCommentHelper(node, comment) { ++ const comments = node.comments || (node.comments = []); ++ comments.push(comment); ++ comment.printed = false; // For some reason, TypeScript parses `// x` inside of JSXText as a comment ++ // We already "print" it via the raw text, we don't need to re-print it as a ++ // comment ++ ++ if (node.type === "JSXText") { ++ comment.printed = true; ++ } ++} ++ ++function addLeadingComment(node, comment) { ++ comment.leading = true; ++ comment.trailing = false; ++ addCommentHelper(node, comment); ++} ++ ++function addDanglingComment(node, comment) { ++ comment.leading = false; ++ comment.trailing = false; ++ addCommentHelper(node, comment); ++} ++ ++function addTrailingComment(node, comment) { ++ comment.leading = false; ++ comment.trailing = true; ++ addCommentHelper(node, comment); ++} ++ ++function isWithinParentArrayProperty(path, propertyName) { ++ const node = path.getValue(); ++ const parent = path.getParentNode(); ++ ++ if (parent == null) { ++ return false; ++ } ++ ++ if (!Array.isArray(parent[propertyName])) { ++ return false; ++ } ++ ++ const key = path.getName(); ++ return parent[propertyName][key] === node; ++} ++ ++function replaceEndOfLineWith(text, replacement) { ++ const parts = []; ++ ++ for (const part of text.split("\n")) { ++ if (parts.length !== 0) { ++ parts.push(replacement); ++ } ++ ++ parts.push(part); ++ } ++ ++ return parts; ++} ++ ++var util$1 = { ++ replaceEndOfLineWith, ++ getStringWidth, ++ getMaxContinuousCount, ++ getMinNotPresentContinuousCount, ++ getPrecedence, ++ shouldFlatten, ++ isBitwiseOperator, ++ getPenultimate, ++ getLast, ++ getNextNonSpaceNonCommentCharacterIndexWithStartIndex, ++ getNextNonSpaceNonCommentCharacterIndex, ++ getNextNonSpaceNonCommentCharacter, ++ skip, ++ skipWhitespace, ++ skipSpaces, ++ skipToLineEnd, ++ skipEverythingButNewLine, ++ skipInlineComment, ++ skipTrailingComment, ++ skipNewline, ++ isNextLineEmptyAfterIndex, ++ isNextLineEmpty, ++ isPreviousLineEmpty, ++ hasNewline, ++ hasNewlineInRange, ++ hasSpaces, ++ setLocStart, ++ setLocEnd, ++ startsWithNoLookaheadToken, ++ getAlignmentSize, ++ getIndentSize, ++ getPreferredQuote, ++ printString, ++ printNumber, ++ hasIgnoreComment, ++ hasNodeIgnoreComment, ++ isNodeIgnoreComment, ++ makeString, ++ addLeadingComment, ++ addDanglingComment, ++ addTrailingComment, ++ isWithinParentArrayProperty ++}; ++ ++function guessEndOfLine(text) { ++ const index = text.indexOf("\r"); ++ ++ if (index >= 0) { ++ return text.charAt(index + 1) === "\n" ? "crlf" : "cr"; ++ } ++ ++ return "lf"; ++} ++ ++function convertEndOfLineToChars(value) { ++ switch (value) { ++ case "cr": ++ return "\r"; ++ ++ case "crlf": ++ return "\r\n"; ++ ++ default: ++ return "\n"; ++ } ++} ++ ++var endOfLine = { ++ guessEndOfLine, ++ convertEndOfLineToChars ++}; ++ ++const { ++ getStringWidth: getStringWidth$1 ++} = util$1; ++const { ++ convertEndOfLineToChars: convertEndOfLineToChars$1 ++} = endOfLine; ++const { ++ concat: concat$1, ++ fill: fill$1, ++ cursor: cursor$1 ++} = docBuilders; ++/** @type {Record} */ ++ ++let groupModeMap; ++const MODE_BREAK = 1; ++const MODE_FLAT = 2; ++ ++function rootIndent() { ++ return { ++ value: "", ++ length: 0, ++ queue: [] ++ }; ++} ++ ++function makeIndent(ind, options) { ++ return generateInd(ind, { ++ type: "indent" ++ }, options); ++} ++ ++function makeAlign(ind, n, options) { ++ return n === -Infinity ? ind.root || rootIndent() : n < 0 ? generateInd(ind, { ++ type: "dedent" ++ }, options) : !n ? ind : n.type === "root" ? Object.assign({}, ind, { ++ root: ind ++ }) : typeof n === "string" ? generateInd(ind, { ++ type: "stringAlign", ++ n ++ }, options) : generateInd(ind, { ++ type: "numberAlign", ++ n ++ }, options); ++} ++ ++function generateInd(ind, newPart, options) { ++ const queue = newPart.type === "dedent" ? ind.queue.slice(0, -1) : ind.queue.concat(newPart); ++ let value = ""; ++ let length = 0; ++ let lastTabs = 0; ++ let lastSpaces = 0; ++ ++ for (const part of queue) { ++ switch (part.type) { ++ case "indent": ++ flush(); ++ ++ if (options.useTabs) { ++ addTabs(1); ++ } else { ++ addSpaces(options.tabWidth); ++ } ++ ++ break; ++ ++ case "stringAlign": ++ flush(); ++ value += part.n; ++ length += part.n.length; ++ break; ++ ++ case "numberAlign": ++ lastTabs += 1; ++ lastSpaces += part.n; ++ break; ++ ++ /* istanbul ignore next */ ++ ++ default: ++ throw new Error(`Unexpected type '${part.type}'`); ++ } ++ } ++ ++ flushSpaces(); ++ return Object.assign({}, ind, { ++ value, ++ length, ++ queue ++ }); ++ ++ function addTabs(count) { ++ value += "\t".repeat(count); ++ length += options.tabWidth * count; ++ } ++ ++ function addSpaces(count) { ++ value += " ".repeat(count); ++ length += count; ++ } ++ ++ function flush() { ++ if (options.useTabs) { ++ flushTabs(); ++ } else { ++ flushSpaces(); ++ } ++ } ++ ++ function flushTabs() { ++ if (lastTabs > 0) { ++ addTabs(lastTabs); ++ } ++ ++ resetLast(); ++ } ++ ++ function flushSpaces() { ++ if (lastSpaces > 0) { ++ addSpaces(lastSpaces); ++ } ++ ++ resetLast(); ++ } ++ ++ function resetLast() { ++ lastTabs = 0; ++ lastSpaces = 0; ++ } ++} ++ ++function trim$1(out) { ++ if (out.length === 0) { ++ return 0; ++ } ++ ++ let trimCount = 0; // Trim whitespace at the end of line ++ ++ while (out.length > 0 && typeof out[out.length - 1] === "string" && out[out.length - 1].match(/^[ \t]*$/)) { ++ trimCount += out.pop().length; ++ } ++ ++ if (out.length && typeof out[out.length - 1] === "string") { ++ const trimmed = out[out.length - 1].replace(/[ \t]*$/, ""); ++ trimCount += out[out.length - 1].length - trimmed.length; ++ out[out.length - 1] = trimmed; ++ } ++ ++ return trimCount; ++} ++ ++function fits(next, restCommands, width, options, mustBeFlat) { ++ let restIdx = restCommands.length; ++ const cmds = [next]; // `out` is only used for width counting because `trim` requires to look ++ // backwards for space characters. ++ ++ const out = []; ++ ++ while (width >= 0) { ++ if (cmds.length === 0) { ++ if (restIdx === 0) { ++ return true; ++ } ++ ++ cmds.push(restCommands[restIdx - 1]); ++ restIdx--; ++ continue; ++ } ++ ++ const [ind, mode, doc] = cmds.pop(); ++ ++ if (typeof doc === "string") { ++ out.push(doc); ++ width -= getStringWidth$1(doc); ++ } else { ++ switch (doc.type) { ++ case "concat": ++ for (let i = doc.parts.length - 1; i >= 0; i--) { ++ cmds.push([ind, mode, doc.parts[i]]); ++ } ++ ++ break; ++ ++ case "indent": ++ cmds.push([makeIndent(ind, options), mode, doc.contents]); ++ break; ++ ++ case "align": ++ cmds.push([makeAlign(ind, doc.n, options), mode, doc.contents]); ++ break; ++ ++ case "trim": ++ width += trim$1(out); ++ break; ++ ++ case "group": ++ if (mustBeFlat && doc.break) { ++ return false; ++ } ++ ++ cmds.push([ind, doc.break ? MODE_BREAK : mode, doc.contents]); ++ ++ if (doc.id) { ++ groupModeMap[doc.id] = cmds[cmds.length - 1][1]; ++ } ++ ++ break; ++ ++ case "fill": ++ for (let i = doc.parts.length - 1; i >= 0; i--) { ++ cmds.push([ind, mode, doc.parts[i]]); ++ } ++ ++ break; ++ ++ case "if-break": ++ { ++ const groupMode = doc.groupId ? groupModeMap[doc.groupId] : mode; ++ ++ if (groupMode === MODE_BREAK) { ++ if (doc.breakContents) { ++ cmds.push([ind, mode, doc.breakContents]); ++ } ++ } ++ ++ if (groupMode === MODE_FLAT) { ++ if (doc.flatContents) { ++ cmds.push([ind, mode, doc.flatContents]); ++ } ++ } ++ ++ break; ++ } ++ ++ case "line": ++ switch (mode) { ++ // fallthrough ++ case MODE_FLAT: ++ if (!doc.hard) { ++ if (!doc.soft) { ++ out.push(" "); ++ width -= 1; ++ } ++ ++ break; ++ } ++ ++ return true; ++ ++ case MODE_BREAK: ++ return true; ++ } ++ ++ break; ++ } ++ } ++ } ++ ++ return false; ++} ++ ++function printDocToString(doc, options) { ++ groupModeMap = {}; ++ const width = options.printWidth; ++ const newLine = convertEndOfLineToChars$1(options.endOfLine); ++ let pos = 0; // cmds is basically a stack. We've turned a recursive call into a ++ // while loop which is much faster. The while loop below adds new ++ // cmds to the array instead of recursively calling `print`. ++ ++ const cmds = [[rootIndent(), MODE_BREAK, doc]]; ++ const out = []; ++ let shouldRemeasure = false; ++ let lineSuffix = []; ++ ++ while (cmds.length !== 0) { ++ const [ind, mode, doc] = cmds.pop(); ++ ++ if (typeof doc === "string") { ++ out.push(doc); ++ pos += getStringWidth$1(doc); ++ } else { ++ switch (doc.type) { ++ case "cursor": ++ out.push(cursor$1.placeholder); ++ break; ++ ++ case "concat": ++ for (let i = doc.parts.length - 1; i >= 0; i--) { ++ cmds.push([ind, mode, doc.parts[i]]); ++ } ++ ++ break; ++ ++ case "indent": ++ cmds.push([makeIndent(ind, options), mode, doc.contents]); ++ break; ++ ++ case "align": ++ cmds.push([makeAlign(ind, doc.n, options), mode, doc.contents]); ++ break; ++ ++ case "trim": ++ pos -= trim$1(out); ++ break; ++ ++ case "group": ++ switch (mode) { ++ case MODE_FLAT: ++ if (!shouldRemeasure) { ++ cmds.push([ind, doc.break ? MODE_BREAK : MODE_FLAT, doc.contents]); ++ break; ++ } ++ ++ // fallthrough ++ ++ case MODE_BREAK: ++ { ++ shouldRemeasure = false; ++ const next = [ind, MODE_FLAT, doc.contents]; ++ const rem = width - pos; ++ ++ if (!doc.break && fits(next, cmds, rem, options)) { ++ cmds.push(next); ++ } else { ++ // Expanded states are a rare case where a document ++ // can manually provide multiple representations of ++ // itself. It provides an array of documents ++ // going from the least expanded (most flattened) ++ // representation first to the most expanded. If a ++ // group has these, we need to manually go through ++ // these states and find the first one that fits. ++ if (doc.expandedStates) { ++ const mostExpanded = doc.expandedStates[doc.expandedStates.length - 1]; ++ ++ if (doc.break) { ++ cmds.push([ind, MODE_BREAK, mostExpanded]); ++ break; ++ } else { ++ for (let i = 1; i < doc.expandedStates.length + 1; i++) { ++ if (i >= doc.expandedStates.length) { ++ cmds.push([ind, MODE_BREAK, mostExpanded]); ++ break; ++ } else { ++ const state = doc.expandedStates[i]; ++ const cmd = [ind, MODE_FLAT, state]; ++ ++ if (fits(cmd, cmds, rem, options)) { ++ cmds.push(cmd); ++ break; ++ } ++ } ++ } ++ } ++ } else { ++ cmds.push([ind, MODE_BREAK, doc.contents]); ++ } ++ } ++ ++ break; ++ } ++ } ++ ++ if (doc.id) { ++ groupModeMap[doc.id] = cmds[cmds.length - 1][1]; ++ } ++ ++ break; ++ // Fills each line with as much code as possible before moving to a new ++ // line with the same indentation. ++ // ++ // Expects doc.parts to be an array of alternating content and ++ // whitespace. The whitespace contains the linebreaks. ++ // ++ // For example: ++ // ["I", line, "love", line, "monkeys"] ++ // or ++ // [{ type: group, ... }, softline, { type: group, ... }] ++ // ++ // It uses this parts structure to handle three main layout cases: ++ // * The first two content items fit on the same line without ++ // breaking ++ // -> output the first content item and the whitespace "flat". ++ // * Only the first content item fits on the line without breaking ++ // -> output the first content item "flat" and the whitespace with ++ // "break". ++ // * Neither content item fits on the line without breaking ++ // -> output the first content item and the whitespace with "break". ++ ++ case "fill": ++ { ++ const rem = width - pos; ++ const { ++ parts ++ } = doc; ++ ++ if (parts.length === 0) { ++ break; ++ } ++ ++ const [content, whitespace] = parts; ++ const contentFlatCmd = [ind, MODE_FLAT, content]; ++ const contentBreakCmd = [ind, MODE_BREAK, content]; ++ const contentFits = fits(contentFlatCmd, [], rem, options, true); ++ ++ if (parts.length === 1) { ++ if (contentFits) { ++ cmds.push(contentFlatCmd); ++ } else { ++ cmds.push(contentBreakCmd); ++ } ++ ++ break; ++ } ++ ++ const whitespaceFlatCmd = [ind, MODE_FLAT, whitespace]; ++ const whitespaceBreakCmd = [ind, MODE_BREAK, whitespace]; ++ ++ if (parts.length === 2) { ++ if (contentFits) { ++ cmds.push(whitespaceFlatCmd); ++ cmds.push(contentFlatCmd); ++ } else { ++ cmds.push(whitespaceBreakCmd); ++ cmds.push(contentBreakCmd); ++ } ++ ++ break; ++ } // At this point we've handled the first pair (context, separator) ++ // and will create a new fill doc for the rest of the content. ++ // Ideally we wouldn't mutate the array here but copying all the ++ // elements to a new array would make this algorithm quadratic, ++ // which is unusable for large arrays (e.g. large texts in JSX). ++ ++ ++ parts.splice(0, 2); ++ const remainingCmd = [ind, mode, fill$1(parts)]; ++ const secondContent = parts[0]; ++ const firstAndSecondContentFlatCmd = [ind, MODE_FLAT, concat$1([content, whitespace, secondContent])]; ++ const firstAndSecondContentFits = fits(firstAndSecondContentFlatCmd, [], rem, options, true); ++ ++ if (firstAndSecondContentFits) { ++ cmds.push(remainingCmd); ++ cmds.push(whitespaceFlatCmd); ++ cmds.push(contentFlatCmd); ++ } else if (contentFits) { ++ cmds.push(remainingCmd); ++ cmds.push(whitespaceBreakCmd); ++ cmds.push(contentFlatCmd); ++ } else { ++ cmds.push(remainingCmd); ++ cmds.push(whitespaceBreakCmd); ++ cmds.push(contentBreakCmd); ++ } ++ ++ break; ++ } ++ ++ case "if-break": ++ { ++ const groupMode = doc.groupId ? groupModeMap[doc.groupId] : mode; ++ ++ if (groupMode === MODE_BREAK) { ++ if (doc.breakContents) { ++ cmds.push([ind, mode, doc.breakContents]); ++ } ++ } ++ ++ if (groupMode === MODE_FLAT) { ++ if (doc.flatContents) { ++ cmds.push([ind, mode, doc.flatContents]); ++ } ++ } ++ ++ break; ++ } ++ ++ case "line-suffix": ++ lineSuffix.push([ind, mode, doc.contents]); ++ break; ++ ++ case "line-suffix-boundary": ++ if (lineSuffix.length > 0) { ++ cmds.push([ind, mode, { ++ type: "line", ++ hard: true ++ }]); ++ } ++ ++ break; ++ ++ case "line": ++ switch (mode) { ++ case MODE_FLAT: ++ if (!doc.hard) { ++ if (!doc.soft) { ++ out.push(" "); ++ pos += 1; ++ } ++ ++ break; ++ } else { ++ // This line was forced into the output even if we ++ // were in flattened mode, so we need to tell the next ++ // group that no matter what, it needs to remeasure ++ // because the previous measurement didn't accurately ++ // capture the entire expression (this is necessary ++ // for nested groups) ++ shouldRemeasure = true; ++ } ++ ++ // fallthrough ++ ++ case MODE_BREAK: ++ if (lineSuffix.length) { ++ cmds.push([ind, mode, doc]); ++ cmds.push(...lineSuffix.reverse()); ++ lineSuffix = []; ++ break; ++ } ++ ++ if (doc.literal) { ++ if (ind.root) { ++ out.push(newLine, ind.root.value); ++ pos = ind.root.length; ++ } else { ++ out.push(newLine); ++ pos = 0; ++ } ++ } else { ++ pos -= trim$1(out); ++ out.push(newLine + ind.value); ++ pos = ind.length; ++ } ++ ++ break; ++ } ++ ++ break; ++ } ++ } ++ } ++ ++ const cursorPlaceholderIndex = out.indexOf(cursor$1.placeholder); ++ ++ if (cursorPlaceholderIndex !== -1) { ++ const otherCursorPlaceholderIndex = out.indexOf(cursor$1.placeholder, cursorPlaceholderIndex + 1); ++ const beforeCursor = out.slice(0, cursorPlaceholderIndex).join(""); ++ const aroundCursor = out.slice(cursorPlaceholderIndex + 1, otherCursorPlaceholderIndex).join(""); ++ const afterCursor = out.slice(otherCursorPlaceholderIndex + 1).join(""); ++ return { ++ formatted: beforeCursor + aroundCursor + afterCursor, ++ cursorNodeStart: beforeCursor.length, ++ cursorNodeText: aroundCursor ++ }; ++ } ++ ++ return { ++ formatted: out.join("") ++ }; ++} ++ ++var docPrinter = { ++ printDocToString ++}; ++ ++const traverseDocOnExitStackMarker = {}; ++ ++function traverseDoc(doc, onEnter, onExit, shouldTraverseConditionalGroups) { ++ const docsStack = [doc]; ++ ++ while (docsStack.length !== 0) { ++ const doc = docsStack.pop(); ++ ++ if (doc === traverseDocOnExitStackMarker) { ++ onExit(docsStack.pop()); ++ continue; ++ } ++ ++ let shouldRecurse = true; ++ ++ if (onEnter) { ++ if (onEnter(doc) === false) { ++ shouldRecurse = false; ++ } ++ } ++ ++ if (onExit) { ++ docsStack.push(doc); ++ docsStack.push(traverseDocOnExitStackMarker); ++ } ++ ++ if (shouldRecurse) { ++ // When there are multiple parts to process, ++ // the parts need to be pushed onto the stack in reverse order, ++ // so that they are processed in the original order ++ // when the stack is popped. ++ if (doc.type === "concat" || doc.type === "fill") { ++ for (let ic = doc.parts.length, i = ic - 1; i >= 0; --i) { ++ docsStack.push(doc.parts[i]); ++ } ++ } else if (doc.type === "if-break") { ++ if (doc.flatContents) { ++ docsStack.push(doc.flatContents); ++ } ++ ++ if (doc.breakContents) { ++ docsStack.push(doc.breakContents); ++ } ++ } else if (doc.type === "group" && doc.expandedStates) { ++ if (shouldTraverseConditionalGroups) { ++ for (let ic = doc.expandedStates.length, i = ic - 1; i >= 0; --i) { ++ docsStack.push(doc.expandedStates[i]); ++ } ++ } else { ++ docsStack.push(doc.contents); ++ } ++ } else if (doc.contents) { ++ docsStack.push(doc.contents); ++ } ++ } ++ } ++} ++ ++function mapDoc(doc, cb) { ++ if (doc.type === "concat" || doc.type === "fill") { ++ const parts = doc.parts.map(part => mapDoc(part, cb)); ++ return cb(Object.assign({}, doc, { ++ parts ++ })); ++ } else if (doc.type === "if-break") { ++ const breakContents = doc.breakContents && mapDoc(doc.breakContents, cb); ++ const flatContents = doc.flatContents && mapDoc(doc.flatContents, cb); ++ return cb(Object.assign({}, doc, { ++ breakContents, ++ flatContents ++ })); ++ } else if (doc.contents) { ++ const contents = mapDoc(doc.contents, cb); ++ return cb(Object.assign({}, doc, { ++ contents ++ })); ++ } ++ ++ return cb(doc); ++} ++ ++function findInDoc(doc, fn, defaultValue) { ++ let result = defaultValue; ++ let hasStopped = false; ++ ++ function findInDocOnEnterFn(doc) { ++ const maybeResult = fn(doc); ++ ++ if (maybeResult !== undefined) { ++ hasStopped = true; ++ result = maybeResult; ++ } ++ ++ if (hasStopped) { ++ return false; ++ } ++ } ++ ++ traverseDoc(doc, findInDocOnEnterFn); ++ return result; ++} ++ ++function isEmpty(n) { ++ return typeof n === "string" && n.length === 0; ++} ++ ++function isLineNextFn(doc) { ++ if (typeof doc === "string") { ++ return false; ++ } ++ ++ if (doc.type === "line") { ++ return true; ++ } ++} ++ ++function isLineNext(doc) { ++ return findInDoc(doc, isLineNextFn, false); ++} ++ ++function willBreakFn(doc) { ++ if (doc.type === "group" && doc.break) { ++ return true; ++ } ++ ++ if (doc.type === "line" && doc.hard) { ++ return true; ++ } ++ ++ if (doc.type === "break-parent") { ++ return true; ++ } ++} ++ ++function willBreak(doc) { ++ return findInDoc(doc, willBreakFn, false); ++} ++ ++function breakParentGroup(groupStack) { ++ if (groupStack.length > 0) { ++ const parentGroup = groupStack[groupStack.length - 1]; // Breaks are not propagated through conditional groups because ++ // the user is expected to manually handle what breaks. ++ ++ if (!parentGroup.expandedStates) { ++ parentGroup.break = true; ++ } ++ } ++ ++ return null; ++} ++ ++function propagateBreaks(doc) { ++ const alreadyVisitedSet = new Set(); ++ const groupStack = []; ++ ++ function propagateBreaksOnEnterFn(doc) { ++ if (doc.type === "break-parent") { ++ breakParentGroup(groupStack); ++ } ++ ++ if (doc.type === "group") { ++ groupStack.push(doc); ++ ++ if (alreadyVisitedSet.has(doc)) { ++ return false; ++ } ++ ++ alreadyVisitedSet.add(doc); ++ } ++ } ++ ++ function propagateBreaksOnExitFn(doc) { ++ if (doc.type === "group") { ++ const group = groupStack.pop(); ++ ++ if (group.break) { ++ breakParentGroup(groupStack); ++ } ++ } ++ } ++ ++ traverseDoc(doc, propagateBreaksOnEnterFn, propagateBreaksOnExitFn, ++ /* shouldTraverseConditionalGroups */ ++ true); ++} ++ ++function removeLinesFn(doc) { ++ // Force this doc into flat mode by statically converting all ++ // lines into spaces (or soft lines into nothing). Hard lines ++ // should still output because there's too great of a chance ++ // of breaking existing assumptions otherwise. ++ if (doc.type === "line" && !doc.hard) { ++ return doc.soft ? "" : " "; ++ } else if (doc.type === "if-break") { ++ return doc.flatContents || ""; ++ } ++ ++ return doc; ++} ++ ++function removeLines(doc) { ++ return mapDoc(doc, removeLinesFn); ++} ++ ++function stripTrailingHardline(doc) { ++ // HACK remove ending hardline, original PR: #1984 ++ if (doc.type === "concat" && doc.parts.length !== 0) { ++ const lastPart = doc.parts[doc.parts.length - 1]; ++ ++ if (lastPart.type === "concat") { ++ if (lastPart.parts.length === 2 && lastPart.parts[0].hard && lastPart.parts[1].type === "break-parent") { ++ return { ++ type: "concat", ++ parts: doc.parts.slice(0, -1) ++ }; ++ } ++ ++ return { ++ type: "concat", ++ parts: doc.parts.slice(0, -1).concat(stripTrailingHardline(lastPart)) ++ }; ++ } ++ } ++ ++ return doc; ++} ++ ++var docUtils = { ++ isEmpty, ++ willBreak, ++ isLineNext, ++ traverseDoc, ++ findInDoc, ++ mapDoc, ++ propagateBreaks, ++ removeLines, ++ stripTrailingHardline ++}; ++ ++function flattenDoc(doc) { ++ if (doc.type === "concat") { ++ const res = []; ++ ++ for (let i = 0; i < doc.parts.length; ++i) { ++ const doc2 = doc.parts[i]; ++ ++ if (typeof doc2 !== "string" && doc2.type === "concat") { ++ res.push(...flattenDoc(doc2).parts); ++ } else { ++ const flattened = flattenDoc(doc2); ++ ++ if (flattened !== "") { ++ res.push(flattened); ++ } ++ } ++ } ++ ++ return Object.assign({}, doc, { ++ parts: res ++ }); ++ } else if (doc.type === "if-break") { ++ return Object.assign({}, doc, { ++ breakContents: doc.breakContents != null ? flattenDoc(doc.breakContents) : null, ++ flatContents: doc.flatContents != null ? flattenDoc(doc.flatContents) : null ++ }); ++ } else if (doc.type === "group") { ++ return Object.assign({}, doc, { ++ contents: flattenDoc(doc.contents), ++ expandedStates: doc.expandedStates ? doc.expandedStates.map(flattenDoc) : doc.expandedStates ++ }); ++ } else if (doc.contents) { ++ return Object.assign({}, doc, { ++ contents: flattenDoc(doc.contents) ++ }); ++ } ++ ++ return doc; ++} ++ ++function printDoc(doc) { ++ if (typeof doc === "string") { ++ return JSON.stringify(doc); ++ } ++ ++ if (doc.type === "line") { ++ if (doc.literal) { ++ return "literalline"; ++ } ++ ++ if (doc.hard) { ++ return "hardline"; ++ } ++ ++ if (doc.soft) { ++ return "softline"; ++ } ++ ++ return "line"; ++ } ++ ++ if (doc.type === "break-parent") { ++ return "breakParent"; ++ } ++ ++ if (doc.type === "trim") { ++ return "trim"; ++ } ++ ++ if (doc.type === "concat") { ++ return "[" + doc.parts.map(printDoc).join(", ") + "]"; ++ } ++ ++ if (doc.type === "indent") { ++ return "indent(" + printDoc(doc.contents) + ")"; ++ } ++ ++ if (doc.type === "align") { ++ return doc.n === -Infinity ? "dedentToRoot(" + printDoc(doc.contents) + ")" : doc.n < 0 ? "dedent(" + printDoc(doc.contents) + ")" : doc.n.type === "root" ? "markAsRoot(" + printDoc(doc.contents) + ")" : "align(" + JSON.stringify(doc.n) + ", " + printDoc(doc.contents) + ")"; ++ } ++ ++ if (doc.type === "if-break") { ++ return "ifBreak(" + printDoc(doc.breakContents) + (doc.flatContents ? ", " + printDoc(doc.flatContents) : "") + ")"; ++ } ++ ++ if (doc.type === "group") { ++ if (doc.expandedStates) { ++ return "conditionalGroup(" + "[" + doc.expandedStates.map(printDoc).join(",") + "])"; ++ } ++ ++ return (doc.break ? "wrappedGroup" : "group") + "(" + printDoc(doc.contents) + ")"; ++ } ++ ++ if (doc.type === "fill") { ++ return "fill" + "(" + doc.parts.map(printDoc).join(", ") + ")"; ++ } ++ ++ if (doc.type === "line-suffix") { ++ return "lineSuffix(" + printDoc(doc.contents) + ")"; ++ } ++ ++ if (doc.type === "line-suffix-boundary") { ++ return "lineSuffixBoundary"; ++ } ++ ++ throw new Error("Unknown doc type " + doc.type); ++} ++ ++var docDebug = { ++ printDocToDebug(doc) { ++ return printDoc(flattenDoc(doc)); ++ } ++ ++}; ++ ++var document = { ++ builders: docBuilders, ++ printer: docPrinter, ++ utils: docUtils, ++ debug: docDebug ++}; ++ ++const { ++ getMaxContinuousCount: getMaxContinuousCount$1, ++ getStringWidth: getStringWidth$2, ++ getAlignmentSize: getAlignmentSize$1, ++ getIndentSize: getIndentSize$1, ++ skip: skip$1, ++ skipWhitespace: skipWhitespace$1, ++ skipSpaces: skipSpaces$1, ++ skipNewline: skipNewline$1, ++ skipToLineEnd: skipToLineEnd$1, ++ skipEverythingButNewLine: skipEverythingButNewLine$1, ++ skipInlineComment: skipInlineComment$1, ++ skipTrailingComment: skipTrailingComment$1, ++ hasNewline: hasNewline$1, ++ hasNewlineInRange: hasNewlineInRange$1, ++ hasSpaces: hasSpaces$1, ++ isNextLineEmpty: isNextLineEmpty$1, ++ isNextLineEmptyAfterIndex: isNextLineEmptyAfterIndex$1, ++ isPreviousLineEmpty: isPreviousLineEmpty$1, ++ getNextNonSpaceNonCommentCharacterIndex: getNextNonSpaceNonCommentCharacterIndex$1, ++ makeString: makeString$1, ++ addLeadingComment: addLeadingComment$1, ++ addDanglingComment: addDanglingComment$1, ++ addTrailingComment: addTrailingComment$1 ++} = util$1; ++var utilShared = { ++ getMaxContinuousCount: getMaxContinuousCount$1, ++ getStringWidth: getStringWidth$2, ++ getAlignmentSize: getAlignmentSize$1, ++ getIndentSize: getIndentSize$1, ++ skip: skip$1, ++ skipWhitespace: skipWhitespace$1, ++ skipSpaces: skipSpaces$1, ++ skipNewline: skipNewline$1, ++ skipToLineEnd: skipToLineEnd$1, ++ skipEverythingButNewLine: skipEverythingButNewLine$1, ++ skipInlineComment: skipInlineComment$1, ++ skipTrailingComment: skipTrailingComment$1, ++ hasNewline: hasNewline$1, ++ hasNewlineInRange: hasNewlineInRange$1, ++ hasSpaces: hasSpaces$1, ++ isNextLineEmpty: isNextLineEmpty$1, ++ isNextLineEmptyAfterIndex: isNextLineEmptyAfterIndex$1, ++ isPreviousLineEmpty: isPreviousLineEmpty$1, ++ getNextNonSpaceNonCommentCharacterIndex: getNextNonSpaceNonCommentCharacterIndex$1, ++ makeString: makeString$1, ++ addLeadingComment: addLeadingComment$1, ++ addDanglingComment: addDanglingComment$1, ++ addTrailingComment: addTrailingComment$1 ++}; ++ ++const { ++ concat: concat$2, ++ line: line$1, ++ hardline: hardline$1, ++ breakParent: breakParent$1, ++ indent: indent$1, ++ lineSuffix: lineSuffix$1, ++ join: join$1, ++ cursor: cursor$2 ++} = document.builders; ++const { ++ hasNewline: hasNewline$2, ++ skipNewline: skipNewline$2, ++ isPreviousLineEmpty: isPreviousLineEmpty$2 ++} = util$1; ++const { ++ addLeadingComment: addLeadingComment$2, ++ addDanglingComment: addDanglingComment$2, ++ addTrailingComment: addTrailingComment$2 ++} = utilShared; ++const childNodesCacheKey = Symbol("child-nodes"); ++ ++function getSortedChildNodes(node, options, resultArray) { ++ if (!node) { ++ return; ++ } ++ ++ const { ++ printer, ++ locStart, ++ locEnd ++ } = options; ++ ++ if (resultArray) { ++ if (printer.canAttachComment && printer.canAttachComment(node)) { ++ // This reverse insertion sort almost always takes constant ++ // time because we almost always (maybe always?) append the ++ // nodes in order anyway. ++ let i; ++ ++ for (i = resultArray.length - 1; i >= 0; --i) { ++ if (locStart(resultArray[i]) <= locStart(node) && locEnd(resultArray[i]) <= locEnd(node)) { ++ break; ++ } ++ } ++ ++ resultArray.splice(i + 1, 0, node); ++ return; ++ } ++ } else if (node[childNodesCacheKey]) { ++ return node[childNodesCacheKey]; ++ } ++ ++ const childNodes = printer.getCommentChildNodes && printer.getCommentChildNodes(node, options) || typeof node === "object" && Object.keys(node).filter(n => n !== "enclosingNode" && n !== "precedingNode" && n !== "followingNode").map(n => node[n]); ++ ++ if (!childNodes) { ++ return; ++ } ++ ++ if (!resultArray) { ++ Object.defineProperty(node, childNodesCacheKey, { ++ value: resultArray = [], ++ enumerable: false ++ }); ++ } ++ ++ childNodes.forEach(childNode => { ++ getSortedChildNodes(childNode, options, resultArray); ++ }); ++ return resultArray; ++} // As efficiently as possible, decorate the comment object with ++// .precedingNode, .enclosingNode, and/or .followingNode properties, at ++// least one of which is guaranteed to be defined. ++ ++ ++function decorateComment(node, comment, options) { ++ const { ++ locStart, ++ locEnd ++ } = options; ++ const childNodes = getSortedChildNodes(node, options); ++ let precedingNode; ++ let followingNode; // Time to dust off the old binary search robes and wizard hat. ++ ++ let left = 0; ++ let right = childNodes.length; ++ ++ while (left < right) { ++ const middle = left + right >> 1; ++ const child = childNodes[middle]; ++ ++ if (locStart(child) - locStart(comment) <= 0 && locEnd(comment) - locEnd(child) <= 0) { ++ // The comment is completely contained by this child node. ++ comment.enclosingNode = child; ++ decorateComment(child, comment, options); ++ return; // Abandon the binary search at this level. ++ } ++ ++ if (locEnd(child) - locStart(comment) <= 0) { ++ // This child node falls completely before the comment. ++ // Because we will never consider this node or any nodes ++ // before it again, this node must be the closest preceding ++ // node we have encountered so far. ++ precedingNode = child; ++ left = middle + 1; ++ continue; ++ } ++ ++ if (locEnd(comment) - locStart(child) <= 0) { ++ // This child node falls completely after the comment. ++ // Because we will never consider this node or any nodes after ++ // it again, this node must be the closest following node we ++ // have encountered so far. ++ followingNode = child; ++ right = middle; ++ continue; ++ } ++ /* istanbul ignore next */ ++ ++ ++ throw new Error("Comment location overlaps with node location"); ++ } // We don't want comments inside of different expressions inside of the same ++ // template literal to move to another expression. ++ ++ ++ if (comment.enclosingNode && comment.enclosingNode.type === "TemplateLiteral") { ++ const { ++ quasis ++ } = comment.enclosingNode; ++ const commentIndex = findExpressionIndexForComment(quasis, comment, options); ++ ++ if (precedingNode && findExpressionIndexForComment(quasis, precedingNode, options) !== commentIndex) { ++ precedingNode = null; ++ } ++ ++ if (followingNode && findExpressionIndexForComment(quasis, followingNode, options) !== commentIndex) { ++ followingNode = null; ++ } ++ } ++ ++ if (precedingNode) { ++ comment.precedingNode = precedingNode; ++ } ++ ++ if (followingNode) { ++ comment.followingNode = followingNode; ++ } ++} ++ ++function attach(comments, ast, text, options) { ++ if (!Array.isArray(comments)) { ++ return; ++ } ++ ++ const tiesToBreak = []; ++ const { ++ locStart, ++ locEnd ++ } = options; ++ comments.forEach((comment, i) => { ++ if (options.parser === "json" || options.parser === "json5" || options.parser === "__js_expression" || options.parser === "__vue_expression") { ++ if (locStart(comment) - locStart(ast) <= 0) { ++ addLeadingComment$2(ast, comment); ++ return; ++ } ++ ++ if (locEnd(comment) - locEnd(ast) >= 0) { ++ addTrailingComment$2(ast, comment); ++ return; ++ } ++ } ++ ++ decorateComment(ast, comment, options); ++ const { ++ precedingNode, ++ enclosingNode, ++ followingNode ++ } = comment; ++ const pluginHandleOwnLineComment = options.printer.handleComments && options.printer.handleComments.ownLine ? options.printer.handleComments.ownLine : () => false; ++ const pluginHandleEndOfLineComment = options.printer.handleComments && options.printer.handleComments.endOfLine ? options.printer.handleComments.endOfLine : () => false; ++ const pluginHandleRemainingComment = options.printer.handleComments && options.printer.handleComments.remaining ? options.printer.handleComments.remaining : () => false; ++ const isLastComment = comments.length - 1 === i; ++ ++ if (hasNewline$2(text, locStart(comment), { ++ backwards: true ++ })) { ++ // If a comment exists on its own line, prefer a leading comment. ++ // We also need to check if it's the first line of the file. ++ if (pluginHandleOwnLineComment(comment, text, options, ast, isLastComment)) ; else if (followingNode) { ++ // Always a leading comment. ++ addLeadingComment$2(followingNode, comment); ++ } else if (precedingNode) { ++ addTrailingComment$2(precedingNode, comment); ++ } else if (enclosingNode) { ++ addDanglingComment$2(enclosingNode, comment); ++ } else { ++ // There are no nodes, let's attach it to the root of the ast ++ ++ /* istanbul ignore next */ ++ addDanglingComment$2(ast, comment); ++ } ++ } else if (hasNewline$2(text, locEnd(comment))) { ++ if (pluginHandleEndOfLineComment(comment, text, options, ast, isLastComment)) ; else if (precedingNode) { ++ // There is content before this comment on the same line, but ++ // none after it, so prefer a trailing comment of the previous node. ++ addTrailingComment$2(precedingNode, comment); ++ } else if (followingNode) { ++ addLeadingComment$2(followingNode, comment); ++ } else if (enclosingNode) { ++ addDanglingComment$2(enclosingNode, comment); ++ } else { ++ // There are no nodes, let's attach it to the root of the ast ++ ++ /* istanbul ignore next */ ++ addDanglingComment$2(ast, comment); ++ } ++ } else { ++ if (pluginHandleRemainingComment(comment, text, options, ast, isLastComment)) ; else if (precedingNode && followingNode) { ++ // Otherwise, text exists both before and after the comment on ++ // the same line. If there is both a preceding and following ++ // node, use a tie-breaking algorithm to determine if it should ++ // be attached to the next or previous node. In the last case, ++ // simply attach the right node; ++ const tieCount = tiesToBreak.length; ++ ++ if (tieCount > 0) { ++ const lastTie = tiesToBreak[tieCount - 1]; ++ ++ if (lastTie.followingNode !== comment.followingNode) { ++ breakTies(tiesToBreak, text, options); ++ } ++ } ++ ++ tiesToBreak.push(comment); ++ } else if (precedingNode) { ++ addTrailingComment$2(precedingNode, comment); ++ } else if (followingNode) { ++ addLeadingComment$2(followingNode, comment); ++ } else if (enclosingNode) { ++ addDanglingComment$2(enclosingNode, comment); ++ } else { ++ // There are no nodes, let's attach it to the root of the ast ++ ++ /* istanbul ignore next */ ++ addDanglingComment$2(ast, comment); ++ } ++ } ++ }); ++ breakTies(tiesToBreak, text, options); ++ comments.forEach(comment => { ++ // These node references were useful for breaking ties, but we ++ // don't need them anymore, and they create cycles in the AST that ++ // may lead to infinite recursion if we don't delete them here. ++ delete comment.precedingNode; ++ delete comment.enclosingNode; ++ delete comment.followingNode; ++ }); ++} ++ ++function breakTies(tiesToBreak, text, options) { ++ const tieCount = tiesToBreak.length; ++ ++ if (tieCount === 0) { ++ return; ++ } ++ ++ const { ++ precedingNode, ++ followingNode, ++ enclosingNode ++ } = tiesToBreak[0]; ++ const gapRegExp = options.printer.getGapRegex && options.printer.getGapRegex(enclosingNode) || /^[\s(]*$/; ++ let gapEndPos = options.locStart(followingNode); // Iterate backwards through tiesToBreak, examining the gaps ++ // between the tied comments. In order to qualify as leading, a ++ // comment must be separated from followingNode by an unbroken series of ++ // gaps (or other comments). Gaps should only contain whitespace or open ++ // parentheses. ++ ++ let indexOfFirstLeadingComment; ++ ++ for (indexOfFirstLeadingComment = tieCount; indexOfFirstLeadingComment > 0; --indexOfFirstLeadingComment) { ++ const comment = tiesToBreak[indexOfFirstLeadingComment - 1]; ++ assert.strictEqual(comment.precedingNode, precedingNode); ++ assert.strictEqual(comment.followingNode, followingNode); ++ const gap = text.slice(options.locEnd(comment), gapEndPos); ++ ++ if (gapRegExp.test(gap)) { ++ gapEndPos = options.locStart(comment); ++ } else { ++ // The gap string contained something other than whitespace or open ++ // parentheses. ++ break; ++ } ++ } ++ ++ tiesToBreak.forEach((comment, i) => { ++ if (i < indexOfFirstLeadingComment) { ++ addTrailingComment$2(precedingNode, comment); ++ } else { ++ addLeadingComment$2(followingNode, comment); ++ } ++ }); ++ tiesToBreak.length = 0; ++} ++ ++function printComment(commentPath, options) { ++ const comment = commentPath.getValue(); ++ comment.printed = true; ++ return options.printer.printComment(commentPath, options); ++} ++ ++function findExpressionIndexForComment(quasis, comment, options) { ++ const startPos = options.locStart(comment) - 1; ++ ++ for (let i = 1; i < quasis.length; ++i) { ++ if (startPos < getQuasiRange(quasis[i]).start) { ++ return i - 1; ++ } ++ } // We haven't found it, it probably means that some of the locations are off. ++ // Let's just return the first one. ++ ++ /* istanbul ignore next */ ++ ++ ++ return 0; ++} ++ ++function getQuasiRange(expr) { ++ if (expr.start !== undefined) { ++ // Babel ++ return { ++ start: expr.start, ++ end: expr.end ++ }; ++ } // Flow ++ ++ ++ return { ++ start: expr.range[0], ++ end: expr.range[1] ++ }; ++} ++ ++function printLeadingComment(commentPath, print, options) { ++ const comment = commentPath.getValue(); ++ const contents = printComment(commentPath, options); ++ ++ if (!contents) { ++ return ""; ++ } ++ ++ const isBlock = options.printer.isBlockComment && options.printer.isBlockComment(comment); // Leading block comments should see if they need to stay on the ++ // same line or not. ++ ++ if (isBlock) { ++ const lineBreak = hasNewline$2(options.originalText, options.locEnd(comment)) ? hasNewline$2(options.originalText, options.locStart(comment), { ++ backwards: true ++ }) ? hardline$1 : line$1 : " "; ++ return concat$2([contents, lineBreak]); ++ } ++ ++ return concat$2([contents, hardline$1]); ++} ++ ++function printTrailingComment(commentPath, print, options) { ++ const comment = commentPath.getValue(); ++ const contents = printComment(commentPath, options); ++ ++ if (!contents) { ++ return ""; ++ } ++ ++ const isBlock = options.printer.isBlockComment && options.printer.isBlockComment(comment); // We don't want the line to break ++ // when the parentParentNode is a ClassDeclaration/-Expression ++ // And the parentNode is in the superClass property ++ ++ const parentNode = commentPath.getNode(1); ++ const parentParentNode = commentPath.getNode(2); ++ const isParentSuperClass = parentParentNode && (parentParentNode.type === "ClassDeclaration" || parentParentNode.type === "ClassExpression") && parentParentNode.superClass === parentNode; ++ ++ if (hasNewline$2(options.originalText, options.locStart(comment), { ++ backwards: true ++ })) { ++ // This allows comments at the end of nested structures: ++ // { ++ // x: 1, ++ // y: 2 ++ // // A comment ++ // } ++ // Those kinds of comments are almost always leading comments, but ++ // here it doesn't go "outside" the block and turns it into a ++ // trailing comment for `2`. We can simulate the above by checking ++ // if this a comment on its own line; normal trailing comments are ++ // always at the end of another expression. ++ const isLineBeforeEmpty = isPreviousLineEmpty$2(options.originalText, comment, options.locStart); ++ return lineSuffix$1(concat$2([hardline$1, isLineBeforeEmpty ? hardline$1 : "", contents])); ++ } else if (isBlock || isParentSuperClass) { ++ // Trailing block comments never need a newline ++ return concat$2([" ", contents]); ++ } ++ ++ return concat$2([lineSuffix$1(concat$2([" ", contents])), !isBlock ? breakParent$1 : ""]); ++} ++ ++function printDanglingComments(path, options, sameIndent, filter) { ++ const parts = []; ++ const node = path.getValue(); ++ ++ if (!node || !node.comments) { ++ return ""; ++ } ++ ++ path.each(commentPath => { ++ const comment = commentPath.getValue(); ++ ++ if (comment && !comment.leading && !comment.trailing && (!filter || filter(comment))) { ++ parts.push(printComment(commentPath, options)); ++ } ++ }, "comments"); ++ ++ if (parts.length === 0) { ++ return ""; ++ } ++ ++ if (sameIndent) { ++ return join$1(hardline$1, parts); ++ } ++ ++ return indent$1(concat$2([hardline$1, join$1(hardline$1, parts)])); ++} ++ ++function prependCursorPlaceholder(path, options, printed) { ++ if (path.getNode() === options.cursorNode && path.getValue()) { ++ return concat$2([cursor$2, printed, cursor$2]); ++ } ++ ++ return printed; ++} ++ ++function printComments(path, print, options, needsSemi) { ++ const value = path.getValue(); ++ const printed = print(path); ++ const comments = value && value.comments; ++ ++ if (!comments || comments.length === 0) { ++ return prependCursorPlaceholder(path, options, printed); ++ } ++ ++ const leadingParts = []; ++ const trailingParts = [needsSemi ? ";" : "", printed]; ++ path.each(commentPath => { ++ const comment = commentPath.getValue(); ++ const { ++ leading, ++ trailing ++ } = comment; ++ ++ if (leading) { ++ const contents = printLeadingComment(commentPath, print, options); ++ ++ if (!contents) { ++ return; ++ } ++ ++ leadingParts.push(contents); ++ const text = options.originalText; ++ const index = skipNewline$2(text, options.locEnd(comment)); ++ ++ if (index !== false && hasNewline$2(text, index)) { ++ leadingParts.push(hardline$1); ++ } ++ } else if (trailing) { ++ trailingParts.push(printTrailingComment(commentPath, print, options)); ++ } ++ }, "comments"); ++ return prependCursorPlaceholder(path, options, concat$2(leadingParts.concat(trailingParts))); ++} ++ ++var comments = { ++ attach, ++ printComments, ++ printDanglingComments, ++ getSortedChildNodes ++}; ++ ++function getNodeHelper(path, count) { ++ const stackIndex = getNodeStackIndexHelper(path.stack, count); ++ return stackIndex === -1 ? null : path.stack[stackIndex]; ++} ++ ++function getNodeStackIndexHelper(stack, count) { ++ for (let i = stack.length - 1; i >= 0; i -= 2) { ++ const value = stack[i]; ++ ++ if (value && !Array.isArray(value) && --count < 0) { ++ return i; ++ } ++ } ++ ++ return -1; ++} ++ ++class FastPath { ++ constructor(value) { ++ this.stack = [value]; ++ } // The name of the current property is always the penultimate element of ++ // this.stack, and always a String. ++ ++ ++ getName() { ++ const { ++ stack ++ } = this; ++ const { ++ length ++ } = stack; ++ ++ if (length > 1) { ++ return stack[length - 2]; ++ } // Since the name is always a string, null is a safe sentinel value to ++ // return if we do not know the name of the (root) value. ++ ++ /* istanbul ignore next */ ++ ++ ++ return null; ++ } // The value of the current property is always the final element of ++ // this.stack. ++ ++ ++ getValue() { ++ return getLast(this.stack); ++ } ++ ++ getNode(count = 0) { ++ return getNodeHelper(this, count); ++ } ++ ++ getParentNode(count = 0) { ++ return getNodeHelper(this, count + 1); ++ } // Temporarily push properties named by string arguments given after the ++ // callback function onto this.stack, then call the callback with a ++ // reference to this (modified) FastPath object. Note that the stack will ++ // be restored to its original state after the callback is finished, so it ++ // is probably a mistake to retain a reference to the path. ++ ++ ++ call(callback, ...names) { ++ const { ++ stack ++ } = this; ++ const { ++ length ++ } = stack; ++ let value = getLast(stack); ++ ++ for (const name of names) { ++ value = value[name]; ++ stack.push(name, value); ++ } ++ ++ const result = callback(this); ++ stack.length = length; ++ return result; ++ } ++ ++ callParent(callback, count = 0) { ++ const stackIndex = getNodeStackIndexHelper(this.stack, count + 1); ++ const parentValues = this.stack.splice(stackIndex + 1); ++ const result = callback(this); ++ this.stack.push(...parentValues); ++ return result; ++ } // Similar to FastPath.prototype.call, except that the value obtained by ++ // accessing this.getValue()[name1][name2]... should be array-like. The ++ // callback will be called with a reference to this path object for each ++ // element of the array. ++ ++ ++ each(callback, ...names) { ++ const { ++ stack ++ } = this; ++ const { ++ length ++ } = stack; ++ let value = getLast(stack); ++ ++ for (const name of names) { ++ value = value[name]; ++ stack.push(name, value); ++ } ++ ++ for (let i = 0; i < value.length; ++i) { ++ if (i in value) { ++ stack.push(i, value[i]); // If the callback needs to know the value of i, call ++ // path.getName(), assuming path is the parameter name. ++ ++ callback(this); ++ stack.length -= 2; ++ } ++ } ++ ++ stack.length = length; ++ } // Similar to FastPath.prototype.each, except that the results of the ++ // callback function invocations are stored in an array and returned at ++ // the end of the iteration. ++ ++ ++ map(callback, ...names) { ++ const { ++ stack ++ } = this; ++ const { ++ length ++ } = stack; ++ let value = getLast(stack); ++ ++ for (const name of names) { ++ value = value[name]; ++ stack.push(name, value); ++ } ++ ++ const result = new Array(value.length); ++ ++ for (let i = 0; i < value.length; ++i) { ++ if (i in value) { ++ stack.push(i, value[i]); ++ result[i] = callback(this, i); ++ stack.length -= 2; ++ } ++ } ++ ++ stack.length = length; ++ return result; ++ } ++ /** ++ * @param {...( ++ * | ((node: any, name: string | null, number: number | null) => boolean) ++ * | undefined ++ * )} predicates ++ */ ++ ++ ++ match(...predicates) { ++ let stackPointer = this.stack.length - 1; ++ let name = null; ++ let node = this.stack[stackPointer--]; ++ ++ for (const predicate of predicates) { ++ if (node === undefined) { ++ return false; ++ } // skip index/array ++ ++ ++ let number = null; ++ ++ if (typeof name === "number") { ++ number = name; ++ name = this.stack[stackPointer--]; ++ node = this.stack[stackPointer--]; ++ } ++ ++ if (predicate && !predicate(node, name, number)) { ++ return false; ++ } ++ ++ name = this.stack[stackPointer--]; ++ node = this.stack[stackPointer--]; ++ } ++ ++ return true; ++ } ++ ++} ++ ++var fastPath = FastPath; ++ ++const { ++ normalize: normalize$2 ++} = options$1; ++ ++function printSubtree(path, print, options, printAstToDoc) { ++ if (options.printer.embed) { ++ return options.printer.embed(path, print, (text, partialNextOptions) => textToDoc(text, partialNextOptions, options, printAstToDoc), options); ++ } ++} ++ ++function textToDoc(text, partialNextOptions, parentOptions, printAstToDoc) { ++ const nextOptions = normalize$2(Object.assign({}, parentOptions, {}, partialNextOptions, { ++ parentParser: parentOptions.parser, ++ embeddedInHtml: !!(parentOptions.embeddedInHtml || parentOptions.parser === "html" || parentOptions.parser === "vue" || parentOptions.parser === "angular" || parentOptions.parser === "lwc"), ++ originalText: text ++ }), { ++ passThrough: true ++ }); ++ const result = parser.parse(text, nextOptions); ++ const { ++ ast ++ } = result; ++ text = result.text; ++ const astComments = ast.comments; ++ delete ast.comments; ++ comments.attach(astComments, ast, text, nextOptions); ++ return printAstToDoc(ast, nextOptions); ++} ++ ++var multiparser = { ++ printSubtree ++}; ++ ++const doc = document; ++const docBuilders$1 = doc.builders; ++const { ++ concat: concat$3, ++ hardline: hardline$2, ++ addAlignmentToDoc: addAlignmentToDoc$1 ++} = docBuilders$1; ++const docUtils$1 = doc.utils; ++/** ++ * Takes an abstract syntax tree (AST) and recursively converts it to a ++ * document (series of printing primitives). ++ * ++ * This is done by descending down the AST recursively. The recursion ++ * involves two functions that call each other: ++ * ++ * 1. printGenerically(), which is defined as an inner function here. ++ * It basically takes care of node caching. ++ * 2. callPluginPrintFunction(), which checks for some options, and ++ * ultimately calls the print() function provided by the plugin. ++ * ++ * The plugin function will call printGenerically() again for child nodes ++ * of the current node, which will do its housekeeping, then call the ++ * plugin function again, and so on. ++ * ++ * All the while, these functions pass a "path" variable around, which ++ * is a stack-like data structure (FastPath) that maintains the current ++ * state of the recursion. It is called "path", because it represents ++ * the path to the current node through the Abstract Syntax Tree. ++ */ ++ ++function printAstToDoc(ast, options, alignmentSize = 0) { ++ const { ++ printer ++ } = options; ++ ++ if (printer.preprocess) { ++ ast = printer.preprocess(ast, options); ++ } ++ ++ const cache = new Map(); ++ ++ function printGenerically(path, args) { ++ const node = path.getValue(); ++ const shouldCache = node && typeof node === "object" && args === undefined; ++ ++ if (shouldCache && cache.has(node)) { ++ return cache.get(node); ++ } // We let JSXElement print its comments itself because it adds () around ++ // UnionTypeAnnotation has to align the child without the comments ++ ++ ++ let res; ++ ++ if (printer.willPrintOwnComments && printer.willPrintOwnComments(path, options)) { ++ res = callPluginPrintFunction(path, options, printGenerically, args); ++ } else { ++ // printComments will call the plugin print function and check for ++ // comments to print ++ res = comments.printComments(path, p => callPluginPrintFunction(p, options, printGenerically, args), options, args && args.needsSemi); ++ } ++ ++ if (shouldCache) { ++ cache.set(node, res); ++ } ++ ++ return res; ++ } ++ ++ let doc = printGenerically(new fastPath(ast)); ++ ++ if (alignmentSize > 0) { ++ // Add a hardline to make the indents take effect ++ // It should be removed in index.js format() ++ doc = addAlignmentToDoc$1(concat$3([hardline$2, doc]), alignmentSize, options.tabWidth); ++ } ++ ++ docUtils$1.propagateBreaks(doc); ++ return doc; ++} ++ ++function callPluginPrintFunction(path, options, printPath, args) { ++ assert.ok(path instanceof fastPath); ++ const node = path.getValue(); ++ const { ++ printer ++ } = options; // Escape hatch ++ ++ if (printer.hasPrettierIgnore && printer.hasPrettierIgnore(path)) { ++ return options.originalText.slice(options.locStart(node), options.locEnd(node)); ++ } ++ ++ if (node) { ++ try { ++ // Potentially switch to a different parser ++ const sub = multiparser.printSubtree(path, printPath, options, printAstToDoc); ++ ++ if (sub) { ++ return sub; ++ } ++ } catch (error) { ++ /* istanbul ignore if */ ++ if (process.env.PRETTIER_DEBUG) { ++ throw error; ++ } // Continue with current parser ++ ++ } ++ } ++ ++ return printer.print(path, options, printPath, args); ++} ++ ++var astToDoc = printAstToDoc; ++ ++function findSiblingAncestors(startNodeAndParents, endNodeAndParents, opts) { ++ let resultStartNode = startNodeAndParents.node; ++ let resultEndNode = endNodeAndParents.node; ++ ++ if (resultStartNode === resultEndNode) { ++ return { ++ startNode: resultStartNode, ++ endNode: resultEndNode ++ }; ++ } ++ ++ for (const endParent of endNodeAndParents.parentNodes) { ++ if (endParent.type !== "Program" && endParent.type !== "File" && opts.locStart(endParent) >= opts.locStart(startNodeAndParents.node)) { ++ resultEndNode = endParent; ++ } else { ++ break; ++ } ++ } ++ ++ for (const startParent of startNodeAndParents.parentNodes) { ++ if (startParent.type !== "Program" && startParent.type !== "File" && opts.locEnd(startParent) <= opts.locEnd(endNodeAndParents.node)) { ++ resultStartNode = startParent; ++ } else { ++ break; ++ } ++ } ++ ++ return { ++ startNode: resultStartNode, ++ endNode: resultEndNode ++ }; ++} ++ ++function findNodeAtOffset(node, offset, options, predicate, parentNodes) { ++ predicate = predicate || (() => true); ++ ++ parentNodes = parentNodes || []; ++ const start = options.locStart(node, options.locStart); ++ const end = options.locEnd(node, options.locEnd); ++ ++ if (start <= offset && offset <= end) { ++ for (const childNode of comments.getSortedChildNodes(node, options)) { ++ const childResult = findNodeAtOffset(childNode, offset, options, predicate, [node].concat(parentNodes)); ++ ++ if (childResult) { ++ return childResult; ++ } ++ } ++ ++ if (predicate(node)) { ++ return { ++ node, ++ parentNodes ++ }; ++ } ++ } ++} // See https://www.ecma-international.org/ecma-262/5.1/#sec-A.5 ++ ++ ++function isSourceElement(opts, node) { ++ if (node == null) { ++ return false; ++ } // JS and JS like to avoid repetitions ++ ++ ++ const jsSourceElements = ["FunctionDeclaration", "BlockStatement", "BreakStatement", "ContinueStatement", "DebuggerStatement", "DoWhileStatement", "EmptyStatement", "ExpressionStatement", "ForInStatement", "ForStatement", "IfStatement", "LabeledStatement", "ReturnStatement", "SwitchStatement", "ThrowStatement", "TryStatement", "VariableDeclaration", "WhileStatement", "WithStatement", "ClassDeclaration", // ES 2015 ++ "ImportDeclaration", // Module ++ "ExportDefaultDeclaration", // Module ++ "ExportNamedDeclaration", // Module ++ "ExportAllDeclaration", // Module ++ "TypeAlias", // Flow ++ "InterfaceDeclaration", // Flow, TypeScript ++ "TypeAliasDeclaration", // TypeScript ++ "ExportAssignment", // TypeScript ++ "ExportDeclaration" // TypeScript ++ ]; ++ const jsonSourceElements = ["ObjectExpression", "ArrayExpression", "StringLiteral", "NumericLiteral", "BooleanLiteral", "NullLiteral"]; ++ const graphqlSourceElements = ["OperationDefinition", "FragmentDefinition", "VariableDefinition", "TypeExtensionDefinition", "ObjectTypeDefinition", "FieldDefinition", "DirectiveDefinition", "EnumTypeDefinition", "EnumValueDefinition", "InputValueDefinition", "InputObjectTypeDefinition", "SchemaDefinition", "OperationTypeDefinition", "InterfaceTypeDefinition", "UnionTypeDefinition", "ScalarTypeDefinition"]; ++ ++ switch (opts.parser) { ++ case "flow": ++ case "babel": ++ case "babel-flow": ++ case "babel-ts": ++ case "typescript": ++ return jsSourceElements.includes(node.type); ++ ++ case "json": ++ return jsonSourceElements.includes(node.type); ++ ++ case "graphql": ++ return graphqlSourceElements.includes(node.kind); ++ ++ case "vue": ++ return node.tag !== "root"; ++ } ++ ++ return false; ++} ++ ++function calculateRange(text, opts, ast) { ++ // Contract the range so that it has non-whitespace characters at its endpoints. ++ // This ensures we can format a range that doesn't end on a node. ++ const rangeStringOrig = text.slice(opts.rangeStart, opts.rangeEnd); ++ const startNonWhitespace = Math.max(opts.rangeStart + rangeStringOrig.search(/\S/), opts.rangeStart); ++ let endNonWhitespace; ++ ++ for (endNonWhitespace = opts.rangeEnd; endNonWhitespace > opts.rangeStart; --endNonWhitespace) { ++ if (text[endNonWhitespace - 1].match(/\S/)) { ++ break; ++ } ++ } ++ ++ const startNodeAndParents = findNodeAtOffset(ast, startNonWhitespace, opts, node => isSourceElement(opts, node)); ++ const endNodeAndParents = findNodeAtOffset(ast, endNonWhitespace, opts, node => isSourceElement(opts, node)); ++ ++ if (!startNodeAndParents || !endNodeAndParents) { ++ return { ++ rangeStart: 0, ++ rangeEnd: 0 ++ }; ++ } ++ ++ const siblingAncestors = findSiblingAncestors(startNodeAndParents, endNodeAndParents, opts); ++ const { ++ startNode, ++ endNode ++ } = siblingAncestors; ++ const rangeStart = Math.min(opts.locStart(startNode, opts.locStart), opts.locStart(endNode, opts.locStart)); ++ const rangeEnd = Math.max(opts.locEnd(startNode, opts.locEnd), opts.locEnd(endNode, opts.locEnd)); ++ return { ++ rangeStart, ++ rangeEnd ++ }; ++} ++ ++var rangeUtil = { ++ calculateRange, ++ findNodeAtOffset ++}; ++ ++var require$$0 = getCjsExportFromNamespace(index_es6); ++ ++const normalizeOptions$1 = options$1.normalize; ++const { ++ guessEndOfLine: guessEndOfLine$1, ++ convertEndOfLineToChars: convertEndOfLineToChars$2 ++} = endOfLine; ++const { ++ utils: { ++ mapDoc: mapDoc$1 ++ }, ++ printer: { ++ printDocToString: printDocToString$1 ++ }, ++ debug: { ++ printDocToDebug ++ } ++} = document; ++const BOM = "\uFEFF"; ++const CURSOR = Symbol("cursor"); ++const PLACEHOLDERS = { ++ cursorOffset: "<<>>", ++ rangeStart: "<<>>", ++ rangeEnd: "<<>>" ++}; ++ ++function ensureAllCommentsPrinted(astComments) { ++ if (!astComments) { ++ return; ++ } ++ ++ for (let i = 0; i < astComments.length; ++i) { ++ if (util$1.isNodeIgnoreComment(astComments[i])) { ++ // If there's a prettier-ignore, we're not printing that sub-tree so we ++ // don't know if the comments was printed or not. ++ return; ++ } ++ } ++ ++ astComments.forEach(comment => { ++ if (!comment.printed) { ++ throw new Error('Comment "' + comment.value.trim() + '" was not printed. Please report this error!'); ++ } ++ ++ delete comment.printed; ++ }); ++} ++ ++function attachComments(text, ast, opts) { ++ const astComments = ast.comments; ++ ++ if (astComments) { ++ delete ast.comments; ++ comments.attach(astComments, ast, text, opts); ++ } ++ ++ ast.tokens = []; ++ opts.originalText = opts.parser === "yaml" ? text : text.trimEnd(); ++ return astComments; ++} ++ ++function coreFormat(text, opts, addAlignmentSize) { ++ if (!text || !text.trim().length) { ++ return { ++ formatted: "", ++ cursorOffset: 0 ++ }; ++ } ++ ++ addAlignmentSize = addAlignmentSize || 0; ++ const parsed = parser.parse(text, opts); ++ const { ++ ast ++ } = parsed; ++ text = parsed.text; ++ ++ if (opts.cursorOffset >= 0) { ++ const nodeResult = rangeUtil.findNodeAtOffset(ast, opts.cursorOffset, opts); ++ ++ if (nodeResult && nodeResult.node) { ++ opts.cursorNode = nodeResult.node; ++ } ++ } ++ ++ const astComments = attachComments(text, ast, opts); ++ const doc = astToDoc(ast, opts, addAlignmentSize); ++ const eol = convertEndOfLineToChars$2(opts.endOfLine); ++ const result = printDocToString$1(opts.endOfLine === "lf" ? doc : mapDoc$1(doc, currentDoc => typeof currentDoc === "string" && currentDoc.includes("\n") ? currentDoc.replace(/\n/g, eol) : currentDoc), opts); ++ ensureAllCommentsPrinted(astComments); // Remove extra leading indentation as well as the added indentation after last newline ++ ++ if (addAlignmentSize > 0) { ++ const trimmed = result.formatted.trim(); ++ ++ if (result.cursorNodeStart !== undefined) { ++ result.cursorNodeStart -= result.formatted.indexOf(trimmed); ++ } ++ ++ result.formatted = trimmed + convertEndOfLineToChars$2(opts.endOfLine); ++ } ++ ++ if (opts.cursorOffset >= 0) { ++ let oldCursorNodeStart; ++ let oldCursorNodeText; ++ let cursorOffsetRelativeToOldCursorNode; ++ let newCursorNodeStart; ++ let newCursorNodeText; ++ ++ if (opts.cursorNode && result.cursorNodeText) { ++ oldCursorNodeStart = opts.locStart(opts.cursorNode); ++ oldCursorNodeText = text.slice(oldCursorNodeStart, opts.locEnd(opts.cursorNode)); ++ cursorOffsetRelativeToOldCursorNode = opts.cursorOffset - oldCursorNodeStart; ++ newCursorNodeStart = result.cursorNodeStart; ++ newCursorNodeText = result.cursorNodeText; ++ } else { ++ oldCursorNodeStart = 0; ++ oldCursorNodeText = text; ++ cursorOffsetRelativeToOldCursorNode = opts.cursorOffset; ++ newCursorNodeStart = 0; ++ newCursorNodeText = result.formatted; ++ } ++ ++ if (oldCursorNodeText === newCursorNodeText) { ++ return { ++ formatted: result.formatted, ++ cursorOffset: newCursorNodeStart + cursorOffsetRelativeToOldCursorNode ++ }; ++ } // diff old and new cursor node texts, with a special cursor ++ // symbol inserted to find out where it moves to ++ ++ ++ const oldCursorNodeCharArray = oldCursorNodeText.split(""); ++ oldCursorNodeCharArray.splice(cursorOffsetRelativeToOldCursorNode, 0, CURSOR); ++ const newCursorNodeCharArray = newCursorNodeText.split(""); ++ const cursorNodeDiff = require$$0.diffArrays(oldCursorNodeCharArray, newCursorNodeCharArray); ++ let cursorOffset = newCursorNodeStart; ++ ++ for (const entry of cursorNodeDiff) { ++ if (entry.removed) { ++ if (entry.value.includes(CURSOR)) { ++ break; ++ } ++ } else { ++ cursorOffset += entry.count; ++ } ++ } ++ ++ return { ++ formatted: result.formatted, ++ cursorOffset ++ }; ++ } ++ ++ return { ++ formatted: result.formatted ++ }; ++} ++ ++function formatRange(text, opts) { ++ const parsed = parser.parse(text, opts); ++ const { ++ ast ++ } = parsed; ++ text = parsed.text; ++ const range = rangeUtil.calculateRange(text, opts, ast); ++ const { ++ rangeStart, ++ rangeEnd ++ } = range; ++ const rangeString = text.slice(rangeStart, rangeEnd); // Try to extend the range backwards to the beginning of the line. ++ // This is so we can detect indentation correctly and restore it. ++ // Use `Math.min` since `lastIndexOf` returns 0 when `rangeStart` is 0 ++ ++ const rangeStart2 = Math.min(rangeStart, text.lastIndexOf("\n", rangeStart) + 1); ++ const indentString = text.slice(rangeStart2, rangeStart); ++ const alignmentSize = util$1.getAlignmentSize(indentString, opts.tabWidth); ++ const rangeResult = coreFormat(rangeString, Object.assign({}, opts, { ++ rangeStart: 0, ++ rangeEnd: Infinity, ++ // track the cursor offset only if it's within our range ++ cursorOffset: opts.cursorOffset >= rangeStart && opts.cursorOffset < rangeEnd ? opts.cursorOffset - rangeStart : -1 ++ }), alignmentSize); // Since the range contracts to avoid trailing whitespace, ++ // we need to remove the newline that was inserted by the `format` call. ++ ++ const rangeTrimmed = rangeResult.formatted.trimEnd(); ++ const rangeLeft = text.slice(0, rangeStart); ++ const rangeRight = text.slice(rangeEnd); ++ let { ++ cursorOffset ++ } = opts; ++ ++ if (opts.cursorOffset >= rangeEnd) { ++ // handle the case where the cursor was past the end of the range ++ cursorOffset = opts.cursorOffset - rangeEnd + (rangeStart + rangeTrimmed.length); ++ } else if (rangeResult.cursorOffset !== undefined) { ++ // handle the case where the cursor was in the range ++ cursorOffset = rangeResult.cursorOffset + rangeStart; ++ } // keep the cursor as it was if it was before the start of the range ++ ++ ++ let formatted; ++ ++ if (opts.endOfLine === "lf") { ++ formatted = rangeLeft + rangeTrimmed + rangeRight; ++ } else { ++ const eol = convertEndOfLineToChars$2(opts.endOfLine); ++ ++ if (cursorOffset >= 0) { ++ const parts = [rangeLeft, rangeTrimmed, rangeRight]; ++ let partIndex = 0; ++ let partOffset = cursorOffset; ++ ++ while (partIndex < parts.length) { ++ const part = parts[partIndex]; ++ ++ if (partOffset < part.length) { ++ parts[partIndex] = parts[partIndex].slice(0, partOffset) + PLACEHOLDERS.cursorOffset + parts[partIndex].slice(partOffset); ++ break; ++ } ++ ++ partIndex++; ++ partOffset -= part.length; ++ } ++ ++ const [newRangeLeft, newRangeTrimmed, newRangeRight] = parts; ++ formatted = (newRangeLeft.replace(/\n/g, eol) + newRangeTrimmed + newRangeRight.replace(/\n/g, eol)).replace(PLACEHOLDERS.cursorOffset, (_, index) => { ++ cursorOffset = index; ++ return ""; ++ }); ++ } else { ++ formatted = rangeLeft.replace(/\n/g, eol) + rangeTrimmed + rangeRight.replace(/\n/g, eol); ++ } ++ } ++ ++ return { ++ formatted, ++ cursorOffset ++ }; ++} ++ ++function format(text, opts) { ++ const selectedParser = parser.resolveParser(opts); ++ const hasPragma = !selectedParser.hasPragma || selectedParser.hasPragma(text); ++ ++ if (opts.requirePragma && !hasPragma) { ++ return { ++ formatted: text ++ }; ++ } ++ ++ if (opts.endOfLine === "auto") { ++ opts.endOfLine = guessEndOfLine$1(text); ++ } ++ ++ const hasCursor = opts.cursorOffset >= 0; ++ const hasRangeStart = opts.rangeStart > 0; ++ const hasRangeEnd = opts.rangeEnd < text.length; // get rid of CR/CRLF parsing ++ ++ if (text.includes("\r")) { ++ const offsetKeys = [hasCursor && "cursorOffset", hasRangeStart && "rangeStart", hasRangeEnd && "rangeEnd"].filter(Boolean).sort((aKey, bKey) => opts[aKey] - opts[bKey]); ++ ++ for (let i = offsetKeys.length - 1; i >= 0; i--) { ++ const key = offsetKeys[i]; ++ text = text.slice(0, opts[key]) + PLACEHOLDERS[key] + text.slice(opts[key]); ++ } ++ ++ text = text.replace(/\r\n?/g, "\n"); ++ ++ for (let i = 0; i < offsetKeys.length; i++) { ++ const key = offsetKeys[i]; ++ text = text.replace(PLACEHOLDERS[key], (_, index) => { ++ opts[key] = index; ++ return ""; ++ }); ++ } ++ } ++ ++ const hasUnicodeBOM = text.charAt(0) === BOM; ++ ++ if (hasUnicodeBOM) { ++ text = text.slice(1); ++ ++ if (hasCursor) { ++ opts.cursorOffset++; ++ } ++ ++ if (hasRangeStart) { ++ opts.rangeStart++; ++ } ++ ++ if (hasRangeEnd) { ++ opts.rangeEnd++; ++ } ++ } ++ ++ if (!hasCursor) { ++ opts.cursorOffset = -1; ++ } ++ ++ if (opts.rangeStart < 0) { ++ opts.rangeStart = 0; ++ } ++ ++ if (opts.rangeEnd > text.length) { ++ opts.rangeEnd = text.length; ++ } ++ ++ const result = hasRangeStart || hasRangeEnd ? formatRange(text, opts) : coreFormat(opts.insertPragma && opts.printer.insertPragma && !hasPragma ? opts.printer.insertPragma(text) : text, opts); ++ ++ if (hasUnicodeBOM) { ++ result.formatted = BOM + result.formatted; ++ ++ if (hasCursor) { ++ result.cursorOffset++; ++ } ++ } ++ ++ return result; ++} ++ ++var core = { ++ formatWithCursor(text, opts) { ++ opts = normalizeOptions$1(opts); ++ return format(text, opts); ++ }, ++ ++ parse(text, opts, massage) { ++ opts = normalizeOptions$1(opts); ++ ++ if (text.includes("\r")) { ++ text = text.replace(/\r\n?/g, "\n"); ++ } ++ ++ const parsed = parser.parse(text, opts); ++ ++ if (massage) { ++ parsed.ast = massageAst(parsed.ast, opts); ++ } ++ ++ return parsed; ++ }, ++ ++ formatAST(ast, opts) { ++ opts = normalizeOptions$1(opts); ++ const doc = astToDoc(ast, opts); ++ return printDocToString$1(doc, opts); ++ }, ++ ++ // Doesn't handle shebang for now ++ formatDoc(doc, opts) { ++ const debug = printDocToDebug(doc); ++ opts = normalizeOptions$1(Object.assign({}, opts, { ++ parser: "babel" ++ })); ++ return format(debug, opts).formatted; ++ }, ++ ++ printToDoc(text, opts) { ++ opts = normalizeOptions$1(opts); ++ const parsed = parser.parse(text, opts); ++ const { ++ ast ++ } = parsed; ++ text = parsed.text; ++ attachComments(text, ast, opts); ++ return astToDoc(ast, opts); ++ }, ++ ++ printDocToString(doc, opts) { ++ return printDocToString$1(doc, normalizeOptions$1(opts)); ++ } ++ ++}; ++ ++// A simple implementation of make-array ++function make_array(subject) { ++ return Array.isArray(subject) ? subject : [subject]; ++} ++ ++const REGEX_BLANK_LINE = /^\s+$/; ++const REGEX_LEADING_EXCAPED_EXCLAMATION = /^\\!/; ++const REGEX_LEADING_EXCAPED_HASH = /^\\#/; ++const SLASH = '/'; ++const KEY_IGNORE = typeof Symbol !== 'undefined' ? Symbol.for('node-ignore') ++/* istanbul ignore next */ ++: 'node-ignore'; ++ ++const define = (object, key, value) => Object.defineProperty(object, key, { ++ value ++}); ++ ++const REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g; // Sanitize the range of a regular expression ++// The cases are complicated, see test cases for details ++ ++const sanitizeRange = range => range.replace(REGEX_REGEXP_RANGE, (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match // Invalid range (out of order) which is ok for gitignore rules but ++// fatal for JavaScript regular expression, so eliminate it. ++: ''); // > If the pattern ends with a slash, ++// > it is removed for the purpose of the following description, ++// > but it would only find a match with a directory. ++// > In other words, foo/ will match a directory foo and paths underneath it, ++// > but will not match a regular file or a symbolic link foo ++// > (this is consistent with the way how pathspec works in general in Git). ++// '`foo/`' will not match regular file '`foo`' or symbolic link '`foo`' ++// -> ignore-rules will not deal with it, because it costs extra `fs.stat` call ++// you could use option `mark: true` with `glob` ++// '`foo/`' should not continue with the '`..`' ++ ++ ++const DEFAULT_REPLACER_PREFIX = [// > Trailing spaces are ignored unless they are quoted with backslash ("\") ++[// (a\ ) -> (a ) ++// (a ) -> (a) ++// (a \ ) -> (a ) ++/\\?\s+$/, match => match.indexOf('\\') === 0 ? ' ' : ''], // replace (\ ) with ' ' ++[/\\\s/g, () => ' '], // Escape metacharacters ++// which is written down by users but means special for regular expressions. ++// > There are 12 characters with special meanings: ++// > - the backslash \, ++// > - the caret ^, ++// > - the dollar sign $, ++// > - the period or dot ., ++// > - the vertical bar or pipe symbol |, ++// > - the question mark ?, ++// > - the asterisk or star *, ++// > - the plus sign +, ++// > - the opening parenthesis (, ++// > - the closing parenthesis ), ++// > - and the opening square bracket [, ++// > - the opening curly brace {, ++// > These special characters are often called "metacharacters". ++[/[\\^$.|*+(){]/g, match => `\\${match}`], [// > [abc] matches any character inside the brackets ++// > (in this case a, b, or c); ++/\[([^\]/]*)($|\])/g, (match, p1, p2) => p2 === ']' ? `[${sanitizeRange(p1)}]` : `\\${match}`], [// > a question mark (?) matches a single character ++/(?!\\)\?/g, () => '[^/]'], // leading slash ++[// > A leading slash matches the beginning of the pathname. ++// > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c". ++// A leading slash matches the beginning of the pathname ++/^\//, () => '^'], // replace special metacharacter slash after the leading slash ++[/\//g, () => '\\/'], [// > A leading "**" followed by a slash means match in all directories. ++// > For example, "**/foo" matches file or directory "foo" anywhere, ++// > the same as pattern "foo". ++// > "**/foo/bar" matches file or directory "bar" anywhere that is directly ++// > under directory "foo". ++// Notice that the '*'s have been replaced as '\\*' ++/^\^*\\\*\\\*\\\//, // '**/foo' <-> 'foo' ++() => '^(?:.*\\/)?']]; ++const DEFAULT_REPLACER_SUFFIX = [// starting ++[// there will be no leading '/' ++// (which has been replaced by section "leading slash") ++// If starts with '**', adding a '^' to the regular expression also works ++/^(?=[^^])/, function startingReplacer() { ++ return !/\/(?!$)/.test(this) // > If the pattern does not contain a slash /, ++ // > Git treats it as a shell glob pattern ++ // Actually, if there is only a trailing slash, ++ // git also treats it as a shell glob pattern ++ ? '(?:^|\\/)' // > Otherwise, Git treats the pattern as a shell glob suitable for ++ // > consumption by fnmatch(3) ++ : '^'; ++}], // two globstars ++[// Use lookahead assertions so that we could match more than one `'/**'` ++/\\\/\\\*\\\*(?=\\\/|$)/g, // Zero, one or several directories ++// should not use '*', or it will be replaced by the next replacer ++// Check if it is not the last `'/**'` ++(match, index, str) => index + 6 < str.length // case: /**/ ++// > A slash followed by two consecutive asterisks then a slash matches ++// > zero or more directories. ++// > For example, "a/**/b" matches "a/b", "a/x/b", "a/x/y/b" and so on. ++// '/**/' ++? '(?:\\/[^\\/]+)*' // case: /** ++// > A trailing `"/**"` matches everything inside. ++// #21: everything inside but it should not include the current folder ++: '\\/.+'], // intermediate wildcards ++[// Never replace escaped '*' ++// ignore rule '\*' will match the path '*' ++// 'abc.*/' -> go ++// 'abc.*' -> skip this rule ++/(^|[^\\]+)\\\*(?=.+)/g, // '*.js' matches '.js' ++// '*.js' doesn't match 'abc' ++(match, p1) => `${p1}[^\\/]*`], // trailing wildcard ++[/(\^|\\\/)?\\\*$/, (match, p1) => { ++ const prefix = p1 // '\^': ++ // '/*' does not match '' ++ // '/*' does not match everything ++ // '\\\/': ++ // 'abc/*' does not match 'abc/' ++ ? `${p1}[^/]+` // 'a*' matches 'a' ++ // 'a*' matches 'aa' ++ : '[^/]*'; ++ return `${prefix}(?=$|\\/$)`; ++}], [// unescape ++/\\\\\\/g, () => '\\']]; ++const POSITIVE_REPLACERS = [...DEFAULT_REPLACER_PREFIX, // 'f' ++// matches ++// - /f(end) ++// - /f/ ++// - (start)f(end) ++// - (start)f/ ++// doesn't match ++// - oof ++// - foo ++// pseudo: ++// -> (^|/)f(/|$) ++// ending ++[// 'js' will not match 'js.' ++// 'ab' will not match 'abc' ++/(?:[^*/])$/, // 'js*' will not match 'a.js' ++// 'js/' will not match 'a.js' ++// 'js' will match 'a.js' and 'a.js/' ++match => `${match}(?=$|\\/)`], ...DEFAULT_REPLACER_SUFFIX]; ++const NEGATIVE_REPLACERS = [...DEFAULT_REPLACER_PREFIX, // #24, #38 ++// The MISSING rule of [gitignore docs](https://git-scm.com/docs/gitignore) ++// A negative pattern without a trailing wildcard should not ++// re-include the things inside that directory. ++// eg: ++// ['node_modules/*', '!node_modules'] ++// should ignore `node_modules/a.js` ++[/(?:[^*])$/, match => `${match}(?=$|\\/$)`], ...DEFAULT_REPLACER_SUFFIX]; // A simple cache, because an ignore rule only has only one certain meaning ++ ++const cache = Object.create(null); // @param {pattern} ++ ++const make_regex = (pattern, negative, ignorecase) => { ++ const r = cache[pattern]; ++ ++ if (r) { ++ return r; ++ } ++ ++ const replacers = negative ? NEGATIVE_REPLACERS : POSITIVE_REPLACERS; ++ const source = replacers.reduce((prev, current) => prev.replace(current[0], current[1].bind(pattern)), pattern); ++ return cache[pattern] = ignorecase ? new RegExp(source, 'i') : new RegExp(source); ++}; // > A blank line matches no files, so it can serve as a separator for readability. ++ ++ ++const checkPattern = pattern => pattern && typeof pattern === 'string' && !REGEX_BLANK_LINE.test(pattern) // > A line starting with # serves as a comment. ++&& pattern.indexOf('#') !== 0; ++ ++const createRule = (pattern, ignorecase) => { ++ const origin = pattern; ++ let negative = false; // > An optional prefix "!" which negates the pattern; ++ ++ if (pattern.indexOf('!') === 0) { ++ negative = true; ++ pattern = pattern.substr(1); ++ } ++ ++ pattern = pattern // > Put a backslash ("\") in front of the first "!" for patterns that ++ // > begin with a literal "!", for example, `"\!important!.txt"`. ++ .replace(REGEX_LEADING_EXCAPED_EXCLAMATION, '!') // > Put a backslash ("\") in front of the first hash for patterns that ++ // > begin with a hash. ++ .replace(REGEX_LEADING_EXCAPED_HASH, '#'); ++ const regex = make_regex(pattern, negative, ignorecase); ++ return { ++ origin, ++ pattern, ++ negative, ++ regex ++ }; ++}; ++ ++class IgnoreBase { ++ constructor({ ++ ignorecase = true ++ } = {}) { ++ this._rules = []; ++ this._ignorecase = ignorecase; ++ define(this, KEY_IGNORE, true); ++ ++ this._initCache(); ++ } ++ ++ _initCache() { ++ this._cache = Object.create(null); ++ } // @param {Array.|string|Ignore} pattern ++ ++ ++ add(pattern) { ++ this._added = false; ++ ++ if (typeof pattern === 'string') { ++ pattern = pattern.split(/\r?\n/g); ++ } ++ ++ make_array(pattern).forEach(this._addPattern, this); // Some rules have just added to the ignore, ++ // making the behavior changed. ++ ++ if (this._added) { ++ this._initCache(); ++ } ++ ++ return this; ++ } // legacy ++ ++ ++ addPattern(pattern) { ++ return this.add(pattern); ++ } ++ ++ _addPattern(pattern) { ++ // #32 ++ if (pattern && pattern[KEY_IGNORE]) { ++ this._rules = this._rules.concat(pattern._rules); ++ this._added = true; ++ return; ++ } ++ ++ if (checkPattern(pattern)) { ++ const rule = createRule(pattern, this._ignorecase); ++ this._added = true; ++ ++ this._rules.push(rule); ++ } ++ } ++ ++ filter(paths) { ++ return make_array(paths).filter(path => this._filter(path)); ++ } ++ ++ createFilter() { ++ return path => this._filter(path); ++ } ++ ++ ignores(path) { ++ return !this._filter(path); ++ } // @returns `Boolean` true if the `path` is NOT ignored ++ ++ ++ _filter(path, slices) { ++ if (!path) { ++ return false; ++ } ++ ++ if (path in this._cache) { ++ return this._cache[path]; ++ } ++ ++ if (!slices) { ++ // path/to/a.js ++ // ['path', 'to', 'a.js'] ++ slices = path.split(SLASH); ++ } ++ ++ slices.pop(); ++ return this._cache[path] = slices.length // > It is not possible to re-include a file if a parent directory of ++ // > that file is excluded. ++ // If the path contains a parent directory, check the parent first ++ ? this._filter(slices.join(SLASH) + SLASH, slices) && this._test(path) // Or only test the path ++ : this._test(path); ++ } // @returns {Boolean} true if a file is NOT ignored ++ ++ ++ _test(path) { ++ // Explicitly define variable type by setting matched to `0` ++ let matched = 0; ++ ++ this._rules.forEach(rule => { ++ // if matched = true, then we only test negative rules ++ // if matched = false, then we test non-negative rules ++ if (!(matched ^ rule.negative)) { ++ matched = rule.negative ^ rule.regex.test(path); ++ } ++ }); ++ ++ return !matched; ++ } ++ ++} // Windows ++// -------------------------------------------------------------- ++ ++/* istanbul ignore if */ ++ ++ ++if ( // Detect `process` so that it can run in browsers. ++typeof process !== 'undefined' && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === 'win32')) { ++ const filter = IgnoreBase.prototype._filter; ++ /* eslint no-control-regex: "off" */ ++ ++ const make_posix = str => /^\\\\\?\\/.test(str) || /[^\x00-\x80]+/.test(str) ? str : str.replace(/\\/g, '/'); ++ ++ IgnoreBase.prototype._filter = function filterWin32(path, slices) { ++ path = make_posix(path); ++ return filter.call(this, path, slices); ++ }; ++} ++ ++var ignore = options => new IgnoreBase(options); ++ ++/** ++ * @param {string} filename ++ * @returns {Promise} ++ */ ++ ++ ++function getFileContentOrNull(filename) { ++ return new Promise((resolve, reject) => { ++ fs$2.readFile(filename, "utf8", (error, data) => { ++ if (error && error.code !== "ENOENT") { ++ reject(createError(filename, error)); ++ } else { ++ resolve(error ? null : data); ++ } ++ }); ++ }); ++} ++/** ++ * @param {string} filename ++ * @returns {null | string} ++ */ ++ ++ ++getFileContentOrNull.sync = function (filename) { ++ try { ++ return fs$2.readFileSync(filename, "utf8"); ++ } catch (error) { ++ if (error && error.code === "ENOENT") { ++ return null; ++ } ++ ++ throw createError(filename, error); ++ } ++}; ++ ++function createError(filename, error) { ++ return new Error(`Unable to read ${filename}: ${error.message}`); ++} ++ ++var getFileContentOrNull_1 = getFileContentOrNull; ++ ++/** ++ * @param {undefined | string} ignorePath ++ * @param {undefined | boolean} withNodeModules ++ */ ++ ++ ++async function createIgnorer(ignorePath, withNodeModules) { ++ const ignoreContent = ignorePath ? await getFileContentOrNull_1(path$1.resolve(ignorePath)) : null; ++ return _createIgnorer(ignoreContent, withNodeModules); ++} ++/** ++ * @param {undefined | string} ignorePath ++ * @param {undefined | boolean} withNodeModules ++ */ ++ ++ ++createIgnorer.sync = function (ignorePath, withNodeModules) { ++ const ignoreContent = !ignorePath ? null : getFileContentOrNull_1.sync(path$1.resolve(ignorePath)); ++ return _createIgnorer(ignoreContent, withNodeModules); ++}; ++/** ++ * @param {null | string} ignoreContent ++ * @param {undefined | boolean} withNodeModules ++ */ ++ ++ ++function _createIgnorer(ignoreContent, withNodeModules) { ++ const ignorer = ignore().add(ignoreContent || ""); ++ ++ if (!withNodeModules) { ++ ignorer.add("node_modules"); ++ } ++ ++ return ignorer; ++} ++ ++var createIgnorer_1 = createIgnorer; ++ ++var thirdParty = require("./third-party"); ++ ++var concatMap = function (xs, fn) { ++ var res = []; ++ ++ for (var i = 0; i < xs.length; i++) { ++ var x = fn(xs[i], i); ++ if (isArray(x)) res.push.apply(res, x);else res.push(x); ++ } ++ ++ return res; ++}; ++ ++var isArray = Array.isArray || function (xs) { ++ return Object.prototype.toString.call(xs) === '[object Array]'; ++}; ++ ++var balancedMatch = balanced; ++ ++function balanced(a, b, str) { ++ if (a instanceof RegExp) a = maybeMatch(a, str); ++ if (b instanceof RegExp) b = maybeMatch(b, str); ++ var r = range(a, b, str); ++ return r && { ++ start: r[0], ++ end: r[1], ++ pre: str.slice(0, r[0]), ++ body: str.slice(r[0] + a.length, r[1]), ++ post: str.slice(r[1] + b.length) ++ }; ++} ++ ++function maybeMatch(reg, str) { ++ var m = str.match(reg); ++ return m ? m[0] : null; ++} ++ ++balanced.range = range; ++ ++function range(a, b, str) { ++ var begs, beg, left, right, result; ++ var ai = str.indexOf(a); ++ var bi = str.indexOf(b, ai + 1); ++ var i = ai; ++ ++ if (ai >= 0 && bi > 0) { ++ begs = []; ++ left = str.length; ++ ++ while (i >= 0 && !result) { ++ if (i == ai) { ++ begs.push(i); ++ ai = str.indexOf(a, i + 1); ++ } else if (begs.length == 1) { ++ result = [begs.pop(), bi]; ++ } else { ++ beg = begs.pop(); ++ ++ if (beg < left) { ++ left = beg; ++ right = bi; ++ } ++ ++ bi = str.indexOf(b, i + 1); ++ } ++ ++ i = ai < bi && ai >= 0 ? ai : bi; ++ } ++ ++ if (begs.length) { ++ result = [left, right]; ++ } ++ } ++ ++ return result; ++} ++ ++var braceExpansion = 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'; ++ ++function numeric$1(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 = balancedMatch('{', '}', 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) { ++ if (!str) return []; // 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), 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$1(i, y) { ++ return i >= y; ++} ++ ++function expand(str, isTop) { ++ var expansions = []; ++ var m = balancedMatch('{', '}', str); ++ if (!m || /\$$/.test(m.pre)) return [str]; ++ 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; ++ return expand(str); ++ } ++ ++ return [str]; ++ } ++ ++ var n; ++ ++ if (isSequence) { ++ n = m.body.split(/\.\./); ++ } else { ++ n = parseCommaParts(m.body); ++ ++ if (n.length === 1) { ++ // x{{a,b}}y ==> x{a}y x{b}y ++ n = expand(n[0], false).map(embrace); ++ ++ if (n.length === 1) { ++ var post = m.post.length ? expand(m.post, false) : ['']; ++ return post.map(function (p) { ++ return m.pre + n[0] + p; ++ }); ++ } ++ } ++ } // at this point, n is the parts, and we know it's not a comma set ++ // with a single entry. ++ // no need to expand pre, since it is guaranteed to be free of brace-sets ++ ++ ++ var pre = m.pre; ++ var post = m.post.length ? expand(m.post, false) : ['']; ++ var N; ++ ++ if (isSequence) { ++ var x = numeric$1(n[0]); ++ var y = numeric$1(n[1]); ++ var width = Math.max(n[0].length, n[1].length); ++ var incr = n.length == 3 ? Math.abs(numeric$1(n[2])) : 1; ++ var test = lte; ++ var reverse = y < x; ++ ++ if (reverse) { ++ incr *= -1; ++ test = gte$1; ++ } ++ ++ var pad = n.some(isPadded); ++ N = []; ++ ++ for (var i = x; test(i, y); 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; ++ } ++ } ++ } ++ ++ N.push(c); ++ } ++ } else { ++ N = concatMap(n, function (el) { ++ return expand(el, false); ++ }); ++ } ++ ++ for (var j = 0; j < N.length; j++) { ++ for (var k = 0; k < post.length; k++) { ++ var expansion = pre + N[j] + post[k]; ++ if (!isTop || isSequence || expansion) expansions.push(expansion); ++ } ++ } ++ ++ return expansions; ++} ++ ++var minimatch_1 = minimatch; ++minimatch.Minimatch = Minimatch; ++var path = { ++ sep: '/' ++}; ++ ++try { ++ path = path$1; ++} catch (er) {} ++ ++var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {}; ++var 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() ++ ++var qmark = '[^/]'; // * => any number of characters ++ ++var 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. ++ ++var twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?'; // not a ^ or / followed by a dot, ++// followed by anything, any number of times. ++ ++var twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?'; // characters that need to be escaped in RegExp. ++ ++var reSpecials = charSet('().*{}+?[]^$\\!'); // "abc" -> { a:true, b:true, c:true } ++ ++function charSet(s) { ++ return s.split('').reduce(function (set, c) { ++ set[c] = true; ++ return set; ++ }, {}); ++} // normalizes slashes. ++ ++ ++var slashSplit = /\/+/; ++minimatch.filter = filter; ++ ++function filter(pattern, options) { ++ options = options || {}; ++ return function (p, i, list) { ++ return minimatch(p, pattern, options); ++ }; ++} ++ ++function ext(a, b) { ++ a = a || {}; ++ b = b || {}; ++ var t = {}; ++ Object.keys(b).forEach(function (k) { ++ t[k] = b[k]; ++ }); ++ Object.keys(a).forEach(function (k) { ++ t[k] = a[k]; ++ }); ++ return t; ++} ++ ++minimatch.defaults = function (def) { ++ if (!def || !Object.keys(def).length) return minimatch; ++ var orig = minimatch; ++ ++ var m = function minimatch(p, pattern, options) { ++ return orig.minimatch(p, pattern, ext(def, options)); ++ }; ++ ++ m.Minimatch = function Minimatch(pattern, options) { ++ return new orig.Minimatch(pattern, ext(def, options)); ++ }; ++ ++ return m; ++}; ++ ++Minimatch.defaults = function (def) { ++ if (!def || !Object.keys(def).length) return Minimatch; ++ return minimatch.defaults(def).Minimatch; ++}; ++ ++function minimatch(p, pattern, options) { ++ if (typeof pattern !== 'string') { ++ throw new TypeError('glob pattern string required'); ++ } ++ ++ if (!options) options = {}; // shortcut: comments match nothing. ++ ++ if (!options.nocomment && pattern.charAt(0) === '#') { ++ return false; ++ } // "" only matches "" ++ ++ ++ if (pattern.trim() === '') return p === ''; ++ return new Minimatch(pattern, options).match(p); ++} ++ ++function Minimatch(pattern, options) { ++ if (!(this instanceof Minimatch)) { ++ return new Minimatch(pattern, options); ++ } ++ ++ if (typeof pattern !== 'string') { ++ throw new TypeError('glob pattern string required'); ++ } ++ ++ if (!options) options = {}; ++ pattern = pattern.trim(); // windows support: need to use /, not \ ++ ++ if (path.sep !== '/') { ++ pattern = pattern.split(path.sep).join('/'); ++ } ++ ++ this.options = options; ++ this.set = []; ++ this.pattern = pattern; ++ this.regexp = null; ++ this.negate = false; ++ this.comment = false; ++ this.empty = false; // make the set of regexps etc. ++ ++ this.make(); ++} ++ ++Minimatch.prototype.debug = function () {}; ++ ++Minimatch.prototype.make = make; ++ ++function make() { ++ // don't do it more than once. ++ if (this._made) return; ++ var pattern = this.pattern; ++ var 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 ++ ++ var set = this.globSet = this.braceExpand(); ++ if (options.debug) this.debug = console.error; ++ 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(function (s) { ++ return s.split(slashSplit); ++ }); ++ this.debug(this.pattern, set); // glob --> regexps ++ ++ set = set.map(function (s, si, set) { ++ return s.map(this.parse, this); ++ }, this); ++ this.debug(this.pattern, set); // filter out everything that didn't compile properly. ++ ++ set = set.filter(function (s) { ++ return s.indexOf(false) === -1; ++ }); ++ this.debug(this.pattern, set); ++ this.set = set; ++} ++ ++Minimatch.prototype.parseNegate = parseNegate; ++ ++function parseNegate() { ++ var pattern = this.pattern; ++ var negate = false; ++ var options = this.options; ++ var negateOffset = 0; ++ if (options.nonegate) return; ++ ++ for (var i = 0, l = pattern.length; i < l && pattern.charAt(i) === '!'; i++) { ++ negate = !negate; ++ negateOffset++; ++ } ++ ++ if (negateOffset) this.pattern = pattern.substr(negateOffset); ++ this.negate = negate; ++} // 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 = function (pattern, options) { ++ return braceExpand(pattern, options); ++}; ++ ++Minimatch.prototype.braceExpand = braceExpand; ++ ++function braceExpand(pattern, options) { ++ if (!options) { ++ if (this instanceof Minimatch) { ++ options = this.options; ++ } else { ++ options = {}; ++ } ++ } ++ ++ pattern = typeof pattern === 'undefined' ? this.pattern : pattern; ++ ++ if (typeof pattern === 'undefined') { ++ throw new TypeError('undefined pattern'); ++ } ++ ++ if (options.nobrace || !pattern.match(/\{.*\}/)) { ++ // shortcut. no need to expand. ++ return [pattern]; ++ } ++ ++ return braceExpansion(pattern); ++} // 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. ++ ++ ++Minimatch.prototype.parse = parse$1; ++var SUBPARSE = {}; ++ ++function parse$1(pattern, isSub) { ++ if (pattern.length > 1024 * 64) { ++ throw new TypeError('pattern is too long'); ++ } ++ ++ var options = this.options; // shortcuts ++ ++ if (!options.noglobstar && pattern === '**') return GLOBSTAR; ++ if (pattern === '') return ''; ++ var re = ''; ++ var hasMagic = !!options.nocase; ++ var escaping = false; // ? => one single character ++ ++ var patternListStack = []; ++ var negativeLists = []; ++ var stateChar; ++ var inClass = false; ++ var reClassStart = -1; ++ var classStart = -1; // . and .. never match anything that doesn't start with ., ++ // even when options.dot is set. ++ ++ var patternStart = pattern.charAt(0) === '.' ? '' // anything ++ // not (start or / followed by . or .. followed by / or end) ++ : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))' : '(?!\\.)'; ++ var self = this; ++ ++ function 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; ++ } ++ ++ self.debug('clearStateChar %j %j', stateChar, re); ++ stateChar = false; ++ } ++ } ++ ++ for (var i = 0, len = pattern.length, c; i < len && (c = pattern.charAt(i)); i++) { ++ this.debug('%s\t%s %s %j', pattern, i, re, c); // skip over any that are escaped. ++ ++ if (escaping && reSpecials[c]) { ++ re += '\\' + c; ++ escaping = false; ++ continue; ++ } ++ ++ switch (c) { ++ case '/': ++ // completely not allowed, even escaped. ++ // Should already be path-split by now. ++ return false; ++ ++ case '\\': ++ 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; ++ } // 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. ++ ++ ++ self.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; ++ } ++ ++ patternListStack.push({ ++ type: stateChar, ++ start: i - 1, ++ reStart: re.length, ++ open: plTypes[stateChar].open, ++ close: plTypes[stateChar].close ++ }); // negation is (?:(?!js)[^/]*) ++ ++ re += stateChar === '!' ? '(?:(?!(?:' : '(?:'; ++ this.debug('plType %j %j', stateChar, re); ++ stateChar = false; ++ continue; ++ ++ case ')': ++ if (inClass || !patternListStack.length) { ++ re += '\\)'; ++ continue; ++ } ++ ++ clearStateChar(); ++ hasMagic = true; ++ var pl = patternListStack.pop(); // negation is (?:(?!js)[^/]*) ++ // The others are (?:) ++ ++ re += pl.close; ++ ++ if (pl.type === '!') { ++ negativeLists.push(pl); ++ } ++ ++ pl.reEnd = re.length; ++ continue; ++ ++ case '|': ++ if (inClass || !patternListStack.length || escaping) { ++ re += '\\|'; ++ escaping = false; ++ continue; ++ } ++ ++ clearStateChar(); ++ re += '|'; ++ 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; ++ escaping = false; ++ continue; ++ } // handle the case where we left a class open. ++ // "[z-a]" is valid, equivalent to "\[z-a\]" ++ ++ ++ if (inClass) { ++ // 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. ++ var cs = pattern.substring(classStart + 1, i); ++ ++ try { ++ RegExp('[' + cs + ']'); ++ } catch (er) { ++ // not a valid class! ++ var sp = this.parse(cs, SUBPARSE); ++ re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]'; ++ hasMagic = hasMagic || sp[1]; ++ inClass = false; ++ continue; ++ } ++ } // finish up the class. ++ ++ ++ hasMagic = true; ++ inClass = false; ++ re += c; ++ continue; ++ ++ default: ++ // swallow any state char that wasn't consumed ++ clearStateChar(); ++ ++ if (escaping) { ++ // no need ++ escaping = false; ++ } else if (reSpecials[c] && !(c === '^' && inClass)) { ++ re += '\\'; ++ } ++ ++ re += c; ++ } // 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.substr(classStart + 1); ++ sp = this.parse(cs, SUBPARSE); ++ re = re.substr(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()) { ++ var 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, function (_, $1, $2) { ++ 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); ++ var 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 ++ ++ ++ var addPatternStart = false; ++ ++ switch (re.charAt(0)) { ++ case '.': ++ case '[': ++ case '(': ++ addPatternStart = true; ++ } // 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 (var n = negativeLists.length - 1; n > -1; n--) { ++ var nl = negativeLists[n]; ++ var nlBefore = re.slice(0, nl.reStart); ++ var nlFirst = re.slice(nl.reStart, nl.reEnd - 8); ++ var nlLast = re.slice(nl.reEnd - 8, nl.reEnd); ++ var nlAfter = re.slice(nl.reEnd); ++ nlLast += 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. ++ ++ var openParensBefore = nlBefore.split('(').length - 1; ++ var cleanAfter = nlAfter; ++ ++ for (i = 0; i < openParensBefore; i++) { ++ cleanAfter = cleanAfter.replace(/\)[+*?]?/, ''); ++ } ++ ++ nlAfter = cleanAfter; ++ var dollar = ''; ++ ++ if (nlAfter === '' && isSub !== SUBPARSE) { ++ dollar = '$'; ++ } ++ ++ var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast; ++ re = newRe; ++ } // 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]; ++ } // 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); ++ } ++ ++ var flags = options.nocase ? 'i' : ''; ++ ++ try { ++ var regExp = new RegExp('^' + re + '$', flags); ++ } catch (er) { ++ // 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('$.'); ++ } ++ ++ regExp._glob = pattern; ++ regExp._src = re; ++ return regExp; ++} ++ ++minimatch.makeRe = function (pattern, options) { ++ return new Minimatch(pattern, options || {}).makeRe(); ++}; ++ ++Minimatch.prototype.makeRe = makeRe; ++ ++function 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. ++ ++ var set = this.set; ++ ++ if (!set.length) { ++ this.regexp = false; ++ return this.regexp; ++ } ++ ++ var options = this.options; ++ var twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot; ++ var flags = options.nocase ? 'i' : ''; ++ var re = set.map(function (pattern) { ++ return pattern.map(function (p) { ++ return p === GLOBSTAR ? twoStar : typeof p === 'string' ? regExpEscape(p) : p._src; ++ }).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) { ++ this.regexp = false; ++ } ++ ++ return this.regexp; ++} ++ ++minimatch.match = function (list, pattern, options) { ++ options = options || {}; ++ var mm = new Minimatch(pattern, options); ++ list = list.filter(function (f) { ++ return mm.match(f); ++ }); ++ ++ if (mm.options.nonull && !list.length) { ++ list.push(pattern); ++ } ++ ++ return list; ++}; ++ ++Minimatch.prototype.match = match; ++ ++function match(f, 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; ++ var 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. ++ ++ var set = this.set; ++ this.debug(this.pattern, 'set', set); // Find the basename of the path by looking for the last non-empty segment ++ ++ var filename; ++ var i; ++ ++ for (i = f.length - 1; i >= 0; i--) { ++ filename = f[i]; ++ if (filename) break; ++ } ++ ++ for (i = 0; i < set.length; i++) { ++ var pattern = set[i]; ++ var file = f; ++ ++ if (options.matchBase && pattern.length === 1) { ++ file = [filename]; ++ } ++ ++ var 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; ++} // 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. ++ ++ ++Minimatch.prototype.matchOne = function (file, pattern, partial) { ++ var options = this.options; ++ this.debug('matchOne', { ++ 'this': this, ++ file: file, ++ pattern: pattern ++ }); ++ this.debug('matchOne', file.length, pattern.length); ++ ++ for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) { ++ this.debug('matchOne loop'); ++ var p = pattern[pi]; ++ var f = file[fi]; ++ this.debug(pattern, p, f); // should be impossible. ++ // some invalid regexp stuff in the set. ++ ++ if (p === false) return false; ++ ++ if (p === GLOBSTAR) { ++ this.debug('GLOBSTAR', [pattern, p, f]); // "**" ++ // a/**/b/**/c would match the following: ++ // a/b/x/y/z/c ++ // a/x/y/z/b/c ++ // a/b/x/b/x/c ++ // a/b/c ++ // To do this, take the rest of the pattern after ++ // the **, and see if it would match the file remainder. ++ // If so, return success. ++ // If not, the ** "swallows" a segment, and try again. ++ // This is recursively awful. ++ // ++ // a/**/b/**/c matching a/b/x/y/z/c ++ // - a matches a ++ // - doublestar ++ // - matchOne(b/x/y/z/c, b/**/c) ++ // - b matches b ++ // - doublestar ++ // - matchOne(x/y/z/c, c) -> no ++ // - matchOne(y/z/c, c) -> no ++ // - matchOne(z/c, c) -> no ++ // - matchOne(c, c) yes, hit ++ ++ var fr = fi; ++ var pr = pi + 1; ++ ++ if (pr === pl) { ++ this.debug('** at the end'); // a ** at the end will just swallow the rest. ++ // We have found a match. ++ // however, it will not swallow /.x, unless ++ // options.dot is set. ++ // . and .. are *never* matched by **, for explosively ++ // exponential reasons. ++ ++ for (; fi < fl; fi++) { ++ if (file[fi] === '.' || file[fi] === '..' || !options.dot && file[fi].charAt(0) === '.') return false; ++ } ++ ++ return true; ++ } // ok, let's see if we can swallow whatever we can. ++ ++ ++ while (fr < fl) { ++ var swallowee = file[fr]; ++ this.debug('\nglobstar while', file, fr, pattern, pr, swallowee); // XXX remove this slice. Just pass the start index. ++ ++ if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) { ++ this.debug('globstar found match!', fr, fl, swallowee); // found a match. ++ ++ return true; ++ } else { ++ // can't swallow "." or ".." ever. ++ // can only swallow ".foo" when explicitly asked. ++ if (swallowee === '.' || swallowee === '..' || !options.dot && swallowee.charAt(0) === '.') { ++ this.debug('dot detected!', file, fr, pattern, pr); ++ break; ++ } // ** swallows a segment, and continue. ++ ++ ++ this.debug('globstar swallow a segment, and continue'); ++ fr++; ++ } ++ } // no match was found. ++ // However, in partial mode, we can't say this is necessarily over. ++ // If there's more *pattern* left, then ++ ++ ++ if (partial) { ++ // ran out of file ++ this.debug('\n>>> no match, partial?', file, fr, pattern, pr); ++ if (fr === fl) return true; ++ } ++ ++ return false; ++ } // something other than ** ++ // non-magic patterns just have to match exactly ++ // patterns with magic have been turned into regexps. ++ ++ ++ var hit; ++ ++ if (typeof p === 'string') { ++ if (options.nocase) { ++ hit = f.toLowerCase() === p.toLowerCase(); ++ } else { ++ 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; ++ } // Note: ending in / means that we'll get a final "" ++ // at the end of the pattern. This can only match a ++ // corresponding "" at the end of the file. ++ // If the file ends in /, then it can only match a ++ // a pattern that ends in /, unless the pattern just ++ // doesn't have any more for it. But, a/b/ should *not* ++ // match "a/b/*", even though "" matches against the ++ // [^/]*? pattern, except in partial mode, where it might ++ // simply not be reached yet. ++ // However, a/b/ should still satisfy a/* ++ // 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 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/ ++ var emptyFileEnd = fi === fl - 1 && file[fi] === ''; ++ return emptyFileEnd; ++ } // should be unreachable. ++ ++ ++ throw new Error('wtf?'); ++}; // replace stuff like \* with * ++ ++ ++function globUnescape(s) { ++ return s.replace(/\\(.)/g, '$1'); ++} ++ ++function regExpEscape(s) { ++ return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&'); ++} ++ ++const copyProperty = (to, from, property, ignoreNonConfigurable) => { ++ // `Function#length` should reflect the parameters of `to` not `from` since we keep its body. ++ // `Function#prototype` is non-writable and non-configurable so can never be modified. ++ if (property === 'length' || property === 'prototype') { ++ return; ++ } ++ ++ const toDescriptor = Object.getOwnPropertyDescriptor(to, property); ++ const fromDescriptor = Object.getOwnPropertyDescriptor(from, property); ++ ++ if (!canCopyProperty(toDescriptor, fromDescriptor) && ignoreNonConfigurable) { ++ return; ++ } ++ ++ Object.defineProperty(to, property, fromDescriptor); ++}; // `Object.defineProperty()` throws if the property exists, is not configurable and either: ++// - one its descriptors is changed ++// - it is non-writable and its value is changed ++ ++ ++const canCopyProperty = function (toDescriptor, fromDescriptor) { ++ return toDescriptor === undefined || toDescriptor.configurable || toDescriptor.writable === fromDescriptor.writable && toDescriptor.enumerable === fromDescriptor.enumerable && toDescriptor.configurable === fromDescriptor.configurable && (toDescriptor.writable || toDescriptor.value === fromDescriptor.value); ++}; ++ ++const changePrototype = (to, from) => { ++ const fromPrototype = Object.getPrototypeOf(from); ++ ++ if (fromPrototype === Object.getPrototypeOf(to)) { ++ return; ++ } ++ ++ Object.setPrototypeOf(to, fromPrototype); ++}; ++ ++const wrappedToString = (withName, fromBody) => `/* Wrapped ${withName}*/\n${fromBody}`; ++ ++const toStringDescriptor = Object.getOwnPropertyDescriptor(Function.prototype, 'toString'); ++const toStringName = Object.getOwnPropertyDescriptor(Function.prototype.toString, 'name'); // We call `from.toString()` early (not lazily) to ensure `from` can be garbage collected. ++// We use `bind()` instead of a closure for the same reason. ++// Calling `from.toString()` early also allows caching it in case `to.toString()` is called several times. ++ ++const changeToString = (to, from, name) => { ++ const withName = name === '' ? '' : `with ${name.trim()}() `; ++ const newToString = wrappedToString.bind(null, withName, from.toString()); // Ensure `to.toString.toString` is non-enumerable and has the same `same` ++ ++ Object.defineProperty(newToString, 'name', toStringName); ++ Object.defineProperty(to, 'toString', Object.assign({}, toStringDescriptor, { ++ value: newToString ++ })); ++}; ++ ++const mimicFn = (to, from, { ++ ignoreNonConfigurable = false ++} = {}) => { ++ const { ++ name ++ } = to; ++ ++ for (const property of Reflect.ownKeys(from)) { ++ copyProperty(to, from, property, ignoreNonConfigurable); ++ } ++ ++ changePrototype(to, from); ++ changeToString(to, from, name); ++ return to; ++}; ++ ++var mimicFn_1 = mimicFn; ++ ++var pDefer = () => { ++ const ret = {}; ++ ret.promise = new Promise((resolve, reject) => { ++ ret.resolve = resolve; ++ ret.reject = reject; ++ }); ++ return ret; ++}; ++ ++var dist = createCommonjsModule(function (module, exports) { ++ ++ var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) { ++ return new (P || (P = Promise))(function (resolve, reject) { ++ function fulfilled(value) { ++ try { ++ step(generator.next(value)); ++ } catch (e) { ++ reject(e); ++ } ++ } ++ ++ function rejected(value) { ++ try { ++ step(generator["throw"](value)); ++ } catch (e) { ++ reject(e); ++ } ++ } ++ ++ function step(result) { ++ result.done ? resolve(result.value) : new P(function (resolve) { ++ resolve(result.value); ++ }).then(fulfilled, rejected); ++ } ++ ++ step((generator = generator.apply(thisArg, _arguments || [])).next()); ++ }); ++ }; ++ ++ var __importDefault = this && this.__importDefault || function (mod) { ++ return mod && mod.__esModule ? mod : { ++ "default": mod ++ }; ++ }; ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ const p_defer_1 = __importDefault(pDefer); ++ ++ function mapAgeCleaner(map, property = 'maxAge') { ++ let processingKey; ++ let processingTimer; ++ let processingDeferred; ++ ++ const cleanup = () => __awaiter(this, void 0, void 0, function* () { ++ if (processingKey !== undefined) { ++ // If we are already processing an item, we can safely exit ++ return; ++ } ++ ++ const setupTimer = item => __awaiter(this, void 0, void 0, function* () { ++ processingDeferred = p_defer_1.default(); ++ const delay = item[1][property] - Date.now(); ++ ++ if (delay <= 0) { ++ // Remove the item immediately if the delay is equal to or below 0 ++ map.delete(item[0]); ++ processingDeferred.resolve(); ++ return; ++ } // Keep track of the current processed key ++ ++ ++ processingKey = item[0]; ++ processingTimer = setTimeout(() => { ++ // Remove the item when the timeout fires ++ map.delete(item[0]); ++ ++ if (processingDeferred) { ++ processingDeferred.resolve(); ++ } ++ }, delay); // tslint:disable-next-line:strict-type-predicates ++ ++ if (typeof processingTimer.unref === 'function') { ++ // Don't hold up the process from exiting ++ processingTimer.unref(); ++ } ++ ++ return processingDeferred.promise; ++ }); ++ ++ try { ++ for (const entry of map) { ++ yield setupTimer(entry); ++ } ++ } catch (_a) {// Do nothing if an error occurs, this means the timer was cleaned up and we should stop processing ++ } ++ ++ processingKey = undefined; ++ }); ++ ++ const reset = () => { ++ processingKey = undefined; ++ ++ if (processingTimer !== undefined) { ++ clearTimeout(processingTimer); ++ processingTimer = undefined; ++ } ++ ++ if (processingDeferred !== undefined) { ++ // tslint:disable-line:early-exit ++ processingDeferred.reject(undefined); ++ processingDeferred = undefined; ++ } ++ }; ++ ++ const originalSet = map.set.bind(map); ++ ++ map.set = (key, value) => { ++ if (map.has(key)) { ++ // If the key already exist, remove it so we can add it back at the end of the map. ++ map.delete(key); ++ } // Call the original `map.set` ++ ++ ++ const result = originalSet(key, value); // If we are already processing a key and the key added is the current processed key, stop processing it ++ ++ if (processingKey && processingKey === key) { ++ reset(); ++ } // Always run the cleanup method in case it wasn't started yet ++ ++ ++ cleanup(); // tslint:disable-line:no-floating-promises ++ ++ return result; ++ }; ++ ++ cleanup(); // tslint:disable-line:no-floating-promises ++ ++ return map; ++ } ++ ++ exports.default = mapAgeCleaner; // Add support for CJS ++ ++ module.exports = mapAgeCleaner; ++ module.exports.default = mapAgeCleaner; ++}); ++unwrapExports(dist); ++ ++const cacheStore = new WeakMap(); ++ ++const mem = (fn, { ++ cacheKey = ([firstArgument]) => firstArgument, ++ cache = new Map(), ++ maxAge ++} = {}) => { ++ if (typeof maxAge === 'number') { ++ dist(cache); ++ } ++ ++ const memoized = function (...arguments_) { ++ const key = cacheKey(arguments_); ++ ++ if (cache.has(key)) { ++ return cache.get(key).data; ++ } ++ ++ const cacheItem = fn.apply(this, arguments_); ++ cache.set(key, { ++ data: cacheItem, ++ maxAge: maxAge ? Date.now() + maxAge : Infinity ++ }); ++ return cacheItem; ++ }; ++ ++ try { ++ // The below call will throw in some host environments ++ // See https://github.com/sindresorhus/mimic-fn/issues/10 ++ mimicFn_1(memoized, fn); ++ } catch (_) {} ++ ++ cacheStore.set(memoized, cache); ++ return memoized; ++}; ++ ++var mem_1 = mem; ++ ++var clear = fn => { ++ if (!cacheStore.has(fn)) { ++ throw new Error('Can\'t clear a function that was not memoized!'); ++ } ++ ++ const cache = cacheStore.get(fn); ++ ++ if (typeof cache.clear === 'function') { ++ cache.clear(); ++ } ++}; ++mem_1.clear = clear; ++ ++var semver$2 = createCommonjsModule(function (module, exports) { ++ exports = module.exports = SemVer; ++ var debug; ++ /* istanbul ignore next */ ++ ++ if (typeof process === 'object' && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG)) { ++ debug = function () { ++ var args = Array.prototype.slice.call(arguments, 0); ++ args.unshift('SEMVER'); ++ console.log.apply(console, args); ++ }; ++ } else { ++ debug = function () {}; ++ } // Note: this is the semver.org version of the spec that it implements ++ // Not necessarily the package version of this code. ++ ++ ++ exports.SEMVER_SPEC_VERSION = '2.0.0'; ++ var MAX_LENGTH = 256; ++ var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || ++ /* istanbul ignore next */ ++ 9007199254740991; // Max safe segment length for coercion. ++ ++ var MAX_SAFE_COMPONENT_LENGTH = 16; // The actual regexps go on exports.re ++ ++ var re = exports.re = []; ++ var src = exports.src = []; ++ var R = 0; // The following Regular Expressions can be used for tokenizing, ++ // validating, and parsing SemVer version strings. ++ // ## Numeric Identifier ++ // A single `0`, or a non-zero digit followed by zero or more digits. ++ ++ var NUMERICIDENTIFIER = R++; ++ src[NUMERICIDENTIFIER] = '0|[1-9]\\d*'; ++ var NUMERICIDENTIFIERLOOSE = R++; ++ src[NUMERICIDENTIFIERLOOSE] = '[0-9]+'; // ## Non-numeric Identifier ++ // Zero or more digits, followed by a letter or hyphen, and then zero or ++ // more letters, digits, or hyphens. ++ ++ var NONNUMERICIDENTIFIER = R++; ++ src[NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*'; // ## Main Version ++ // Three dot-separated numeric identifiers. ++ ++ var MAINVERSION = R++; ++ src[MAINVERSION] = '(' + src[NUMERICIDENTIFIER] + ')\\.' + '(' + src[NUMERICIDENTIFIER] + ')\\.' + '(' + src[NUMERICIDENTIFIER] + ')'; ++ var MAINVERSIONLOOSE = R++; ++ src[MAINVERSIONLOOSE] = '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' + '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' + '(' + src[NUMERICIDENTIFIERLOOSE] + ')'; // ## Pre-release Version Identifier ++ // A numeric identifier, or a non-numeric identifier. ++ ++ var PRERELEASEIDENTIFIER = R++; ++ src[PRERELEASEIDENTIFIER] = '(?:' + src[NUMERICIDENTIFIER] + '|' + src[NONNUMERICIDENTIFIER] + ')'; ++ var PRERELEASEIDENTIFIERLOOSE = R++; ++ src[PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[NUMERICIDENTIFIERLOOSE] + '|' + src[NONNUMERICIDENTIFIER] + ')'; // ## Pre-release Version ++ // Hyphen, followed by one or more dot-separated pre-release version ++ // identifiers. ++ ++ var PRERELEASE = R++; ++ src[PRERELEASE] = '(?:-(' + src[PRERELEASEIDENTIFIER] + '(?:\\.' + src[PRERELEASEIDENTIFIER] + ')*))'; ++ var PRERELEASELOOSE = R++; ++ src[PRERELEASELOOSE] = '(?:-?(' + src[PRERELEASEIDENTIFIERLOOSE] + '(?:\\.' + src[PRERELEASEIDENTIFIERLOOSE] + ')*))'; // ## Build Metadata Identifier ++ // Any combination of digits, letters, or hyphens. ++ ++ var BUILDIDENTIFIER = R++; ++ src[BUILDIDENTIFIER] = '[0-9A-Za-z-]+'; // ## Build Metadata ++ // Plus sign, followed by one or more period-separated build metadata ++ // identifiers. ++ ++ var BUILD = R++; ++ src[BUILD] = '(?:\\+(' + src[BUILDIDENTIFIER] + '(?:\\.' + src[BUILDIDENTIFIER] + ')*))'; // ## Full Version String ++ // A main version, followed optionally by a pre-release version and ++ // build metadata. ++ // Note that the only major, minor, patch, and pre-release sections of ++ // the version string are capturing groups. The build metadata is not a ++ // capturing group, because it should not ever be used in version ++ // comparison. ++ ++ var FULL = R++; ++ var FULLPLAIN = 'v?' + src[MAINVERSION] + src[PRERELEASE] + '?' + src[BUILD] + '?'; ++ src[FULL] = '^' + FULLPLAIN + '$'; // like full, but allows v1.2.3 and =1.2.3, which people do sometimes. ++ // also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty ++ // common in the npm registry. ++ ++ var LOOSEPLAIN = '[v=\\s]*' + src[MAINVERSIONLOOSE] + src[PRERELEASELOOSE] + '?' + src[BUILD] + '?'; ++ var LOOSE = R++; ++ src[LOOSE] = '^' + LOOSEPLAIN + '$'; ++ var GTLT = R++; ++ src[GTLT] = '((?:<|>)?=?)'; // Something like "2.*" or "1.2.x". ++ // Note that "x.x" is a valid xRange identifer, meaning "any version" ++ // Only the first item is strictly required. ++ ++ var XRANGEIDENTIFIERLOOSE = R++; ++ src[XRANGEIDENTIFIERLOOSE] = src[NUMERICIDENTIFIERLOOSE] + '|x|X|\\*'; ++ var XRANGEIDENTIFIER = R++; ++ src[XRANGEIDENTIFIER] = src[NUMERICIDENTIFIER] + '|x|X|\\*'; ++ var XRANGEPLAIN = R++; ++ src[XRANGEPLAIN] = '[v=\\s]*(' + src[XRANGEIDENTIFIER] + ')' + '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' + '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' + '(?:' + src[PRERELEASE] + ')?' + src[BUILD] + '?' + ')?)?'; ++ var XRANGEPLAINLOOSE = R++; ++ src[XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[XRANGEIDENTIFIERLOOSE] + ')' + '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' + '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' + '(?:' + src[PRERELEASELOOSE] + ')?' + src[BUILD] + '?' + ')?)?'; ++ var XRANGE = R++; ++ src[XRANGE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAIN] + '$'; ++ var XRANGELOOSE = R++; ++ src[XRANGELOOSE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAINLOOSE] + '$'; // Coercion. ++ // Extract anything that could conceivably be a part of a valid semver ++ ++ var COERCE = R++; ++ src[COERCE] = '(?:^|[^\\d])' + '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' + '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + '(?:$|[^\\d])'; // Tilde ranges. ++ // Meaning is "reasonably at or greater than" ++ ++ var LONETILDE = R++; ++ src[LONETILDE] = '(?:~>?)'; ++ var TILDETRIM = R++; ++ src[TILDETRIM] = '(\\s*)' + src[LONETILDE] + '\\s+'; ++ re[TILDETRIM] = new RegExp(src[TILDETRIM], 'g'); ++ var tildeTrimReplace = '$1~'; ++ var TILDE = R++; ++ src[TILDE] = '^' + src[LONETILDE] + src[XRANGEPLAIN] + '$'; ++ var TILDELOOSE = R++; ++ src[TILDELOOSE] = '^' + src[LONETILDE] + src[XRANGEPLAINLOOSE] + '$'; // Caret ranges. ++ // Meaning is "at least and backwards compatible with" ++ ++ var LONECARET = R++; ++ src[LONECARET] = '(?:\\^)'; ++ var CARETTRIM = R++; ++ src[CARETTRIM] = '(\\s*)' + src[LONECARET] + '\\s+'; ++ re[CARETTRIM] = new RegExp(src[CARETTRIM], 'g'); ++ var caretTrimReplace = '$1^'; ++ var CARET = R++; ++ src[CARET] = '^' + src[LONECARET] + src[XRANGEPLAIN] + '$'; ++ var CARETLOOSE = R++; ++ src[CARETLOOSE] = '^' + src[LONECARET] + src[XRANGEPLAINLOOSE] + '$'; // A simple gt/lt/eq thing, or just "" to indicate "any version" ++ ++ var COMPARATORLOOSE = R++; ++ src[COMPARATORLOOSE] = '^' + src[GTLT] + '\\s*(' + LOOSEPLAIN + ')$|^$'; ++ var COMPARATOR = R++; ++ src[COMPARATOR] = '^' + src[GTLT] + '\\s*(' + FULLPLAIN + ')$|^$'; // An expression to strip any whitespace between the gtlt and the thing ++ // it modifies, so that `> 1.2.3` ==> `>1.2.3` ++ ++ var COMPARATORTRIM = R++; ++ src[COMPARATORTRIM] = '(\\s*)' + src[GTLT] + '\\s*(' + LOOSEPLAIN + '|' + src[XRANGEPLAIN] + ')'; // this one has to use the /g flag ++ ++ re[COMPARATORTRIM] = new RegExp(src[COMPARATORTRIM], 'g'); ++ var comparatorTrimReplace = '$1$2$3'; // Something like `1.2.3 - 1.2.4` ++ // Note that these all use the loose form, because they'll be ++ // checked against either the strict or loose comparator form ++ // later. ++ ++ var HYPHENRANGE = R++; ++ src[HYPHENRANGE] = '^\\s*(' + src[XRANGEPLAIN] + ')' + '\\s+-\\s+' + '(' + src[XRANGEPLAIN] + ')' + '\\s*$'; ++ var HYPHENRANGELOOSE = R++; ++ src[HYPHENRANGELOOSE] = '^\\s*(' + src[XRANGEPLAINLOOSE] + ')' + '\\s+-\\s+' + '(' + src[XRANGEPLAINLOOSE] + ')' + '\\s*$'; // Star ranges basically just allow anything at all. ++ ++ var STAR = R++; ++ src[STAR] = '(<|>)?=?\\s*\\*'; // Compile to actual regexp objects. ++ // All are flag-free, unless they were created above with a flag. ++ ++ for (var i = 0; i < R; i++) { ++ debug(i, src[i]); ++ ++ if (!re[i]) { ++ re[i] = new RegExp(src[i]); ++ } ++ } ++ ++ exports.parse = parse; ++ ++ function parse(version, options) { ++ if (!options || typeof options !== 'object') { ++ options = { ++ loose: !!options, ++ includePrerelease: false ++ }; ++ } ++ ++ if (version instanceof SemVer) { ++ return version; ++ } ++ ++ if (typeof version !== 'string') { ++ return null; ++ } ++ ++ if (version.length > MAX_LENGTH) { ++ return null; ++ } ++ ++ var r = options.loose ? re[LOOSE] : re[FULL]; ++ ++ if (!r.test(version)) { ++ return null; ++ } ++ ++ try { ++ return new SemVer(version, options); ++ } catch (er) { ++ return null; ++ } ++ } ++ ++ exports.valid = valid; ++ ++ function valid(version, options) { ++ var v = parse(version, options); ++ return v ? v.version : null; ++ } ++ ++ exports.clean = clean; ++ ++ function clean(version, options) { ++ var s = parse(version.trim().replace(/^[=v]+/, ''), options); ++ return s ? s.version : null; ++ } ++ ++ exports.SemVer = SemVer; ++ ++ function SemVer(version, options) { ++ if (!options || typeof options !== 'object') { ++ options = { ++ loose: !!options, ++ includePrerelease: false ++ }; ++ } ++ ++ if (version instanceof SemVer) { ++ if (version.loose === options.loose) { ++ return version; ++ } else { ++ version = version.version; ++ } ++ } else if (typeof version !== 'string') { ++ throw new TypeError('Invalid Version: ' + version); ++ } ++ ++ if (version.length > MAX_LENGTH) { ++ throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters'); ++ } ++ ++ if (!(this instanceof SemVer)) { ++ return new SemVer(version, options); ++ } ++ ++ debug('SemVer', version, options); ++ this.options = options; ++ this.loose = !!options.loose; ++ var m = version.trim().match(options.loose ? re[LOOSE] : re[FULL]); ++ ++ if (!m) { ++ throw new TypeError('Invalid Version: ' + version); ++ } ++ ++ this.raw = version; // these are actually numbers ++ ++ this.major = +m[1]; ++ this.minor = +m[2]; ++ this.patch = +m[3]; ++ ++ if (this.major > MAX_SAFE_INTEGER || this.major < 0) { ++ throw new TypeError('Invalid major version'); ++ } ++ ++ if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) { ++ throw new TypeError('Invalid minor version'); ++ } ++ ++ if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) { ++ throw new TypeError('Invalid patch version'); ++ } // numberify any prerelease numeric ids ++ ++ ++ if (!m[4]) { ++ this.prerelease = []; ++ } else { ++ this.prerelease = m[4].split('.').map(function (id) { ++ if (/^[0-9]+$/.test(id)) { ++ var num = +id; ++ ++ if (num >= 0 && num < MAX_SAFE_INTEGER) { ++ return num; ++ } ++ } ++ ++ return id; ++ }); ++ } ++ ++ this.build = m[5] ? m[5].split('.') : []; ++ this.format(); ++ } ++ ++ SemVer.prototype.format = function () { ++ this.version = this.major + '.' + this.minor + '.' + this.patch; ++ ++ if (this.prerelease.length) { ++ this.version += '-' + this.prerelease.join('.'); ++ } ++ ++ return this.version; ++ }; ++ ++ SemVer.prototype.toString = function () { ++ return this.version; ++ }; ++ ++ SemVer.prototype.compare = function (other) { ++ debug('SemVer.compare', this.version, this.options, other); ++ ++ if (!(other instanceof SemVer)) { ++ other = new SemVer(other, this.options); ++ } ++ ++ return this.compareMain(other) || this.comparePre(other); ++ }; ++ ++ SemVer.prototype.compareMain = function (other) { ++ if (!(other instanceof SemVer)) { ++ other = new SemVer(other, this.options); ++ } ++ ++ return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch); ++ }; ++ ++ SemVer.prototype.comparePre = function (other) { ++ if (!(other instanceof SemVer)) { ++ other = new SemVer(other, this.options); ++ } // NOT having a prerelease is > having one ++ ++ ++ if (this.prerelease.length && !other.prerelease.length) { ++ return -1; ++ } else if (!this.prerelease.length && other.prerelease.length) { ++ return 1; ++ } else if (!this.prerelease.length && !other.prerelease.length) { ++ return 0; ++ } ++ ++ var i = 0; ++ ++ do { ++ var a = this.prerelease[i]; ++ var b = other.prerelease[i]; ++ debug('prerelease compare', i, a, b); ++ ++ if (a === undefined && b === undefined) { ++ return 0; ++ } else if (b === undefined) { ++ return 1; ++ } else if (a === undefined) { ++ return -1; ++ } else if (a === b) { ++ continue; ++ } else { ++ return compareIdentifiers(a, b); ++ } ++ } while (++i); ++ }; // preminor will bump the version up to the next minor release, and immediately ++ // down to pre-release. premajor and prepatch work the same way. ++ ++ ++ SemVer.prototype.inc = function (release, identifier) { ++ switch (release) { ++ case 'premajor': ++ this.prerelease.length = 0; ++ this.patch = 0; ++ this.minor = 0; ++ this.major++; ++ this.inc('pre', identifier); ++ break; ++ ++ case 'preminor': ++ this.prerelease.length = 0; ++ this.patch = 0; ++ this.minor++; ++ this.inc('pre', identifier); ++ break; ++ ++ case 'prepatch': ++ // If this is already a prerelease, it will bump to the next version ++ // drop any prereleases that might already exist, since they are not ++ // relevant at this point. ++ this.prerelease.length = 0; ++ this.inc('patch', identifier); ++ this.inc('pre', identifier); ++ break; ++ // If the input is a non-prerelease version, this acts the same as ++ // prepatch. ++ ++ case 'prerelease': ++ if (this.prerelease.length === 0) { ++ this.inc('patch', identifier); ++ } ++ ++ this.inc('pre', identifier); ++ break; ++ ++ case 'major': ++ // If this is a pre-major version, bump up to the same major version. ++ // Otherwise increment major. ++ // 1.0.0-5 bumps to 1.0.0 ++ // 1.1.0 bumps to 2.0.0 ++ if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) { ++ this.major++; ++ } ++ ++ this.minor = 0; ++ this.patch = 0; ++ this.prerelease = []; ++ break; ++ ++ case 'minor': ++ // If this is a pre-minor version, bump up to the same minor version. ++ // Otherwise increment minor. ++ // 1.2.0-5 bumps to 1.2.0 ++ // 1.2.1 bumps to 1.3.0 ++ if (this.patch !== 0 || this.prerelease.length === 0) { ++ this.minor++; ++ } ++ ++ this.patch = 0; ++ this.prerelease = []; ++ break; ++ ++ case 'patch': ++ // If this is not a pre-release version, it will increment the patch. ++ // If it is a pre-release it will bump up to the same patch version. ++ // 1.2.0-5 patches to 1.2.0 ++ // 1.2.0 patches to 1.2.1 ++ if (this.prerelease.length === 0) { ++ this.patch++; ++ } ++ ++ this.prerelease = []; ++ break; ++ // This probably shouldn't be used publicly. ++ // 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction. ++ ++ case 'pre': ++ if (this.prerelease.length === 0) { ++ this.prerelease = [0]; ++ } else { ++ var i = this.prerelease.length; ++ ++ while (--i >= 0) { ++ if (typeof this.prerelease[i] === 'number') { ++ this.prerelease[i]++; ++ i = -2; ++ } ++ } ++ ++ if (i === -1) { ++ // didn't increment anything ++ this.prerelease.push(0); ++ } ++ } ++ ++ if (identifier) { ++ // 1.2.0-beta.1 bumps to 1.2.0-beta.2, ++ // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0 ++ if (this.prerelease[0] === identifier) { ++ if (isNaN(this.prerelease[1])) { ++ this.prerelease = [identifier, 0]; ++ } ++ } else { ++ this.prerelease = [identifier, 0]; ++ } ++ } ++ ++ break; ++ ++ default: ++ throw new Error('invalid increment argument: ' + release); ++ } ++ ++ this.format(); ++ this.raw = this.version; ++ return this; ++ }; ++ ++ exports.inc = inc; ++ ++ function inc(version, release, loose, identifier) { ++ if (typeof loose === 'string') { ++ identifier = loose; ++ loose = undefined; ++ } ++ ++ try { ++ return new SemVer(version, loose).inc(release, identifier).version; ++ } catch (er) { ++ return null; ++ } ++ } ++ ++ exports.diff = diff; ++ ++ function diff(version1, version2) { ++ if (eq(version1, version2)) { ++ return null; ++ } else { ++ var v1 = parse(version1); ++ var v2 = parse(version2); ++ var prefix = ''; ++ ++ if (v1.prerelease.length || v2.prerelease.length) { ++ prefix = 'pre'; ++ var defaultResult = 'prerelease'; ++ } ++ ++ for (var key in v1) { ++ if (key === 'major' || key === 'minor' || key === 'patch') { ++ if (v1[key] !== v2[key]) { ++ return prefix + key; ++ } ++ } ++ } ++ ++ return defaultResult; // may be undefined ++ } ++ } ++ ++ exports.compareIdentifiers = compareIdentifiers; ++ var numeric = /^[0-9]+$/; ++ ++ function compareIdentifiers(a, b) { ++ var anum = numeric.test(a); ++ var bnum = numeric.test(b); ++ ++ if (anum && bnum) { ++ a = +a; ++ b = +b; ++ } ++ ++ return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1; ++ } ++ ++ exports.rcompareIdentifiers = rcompareIdentifiers; ++ ++ function rcompareIdentifiers(a, b) { ++ return compareIdentifiers(b, a); ++ } ++ ++ exports.major = major; ++ ++ function major(a, loose) { ++ return new SemVer(a, loose).major; ++ } ++ ++ exports.minor = minor; ++ ++ function minor(a, loose) { ++ return new SemVer(a, loose).minor; ++ } ++ ++ exports.patch = patch; ++ ++ function patch(a, loose) { ++ return new SemVer(a, loose).patch; ++ } ++ ++ exports.compare = compare; ++ ++ function compare(a, b, loose) { ++ return new SemVer(a, loose).compare(new SemVer(b, loose)); ++ } ++ ++ exports.compareLoose = compareLoose; ++ ++ function compareLoose(a, b) { ++ return compare(a, b, true); ++ } ++ ++ exports.rcompare = rcompare; ++ ++ function rcompare(a, b, loose) { ++ return compare(b, a, loose); ++ } ++ ++ exports.sort = sort; ++ ++ function sort(list, loose) { ++ return list.sort(function (a, b) { ++ return exports.compare(a, b, loose); ++ }); ++ } ++ ++ exports.rsort = rsort; ++ ++ function rsort(list, loose) { ++ return list.sort(function (a, b) { ++ return exports.rcompare(a, b, loose); ++ }); ++ } ++ ++ exports.gt = gt; ++ ++ function gt(a, b, loose) { ++ return compare(a, b, loose) > 0; ++ } ++ ++ exports.lt = lt; ++ ++ function lt(a, b, loose) { ++ return compare(a, b, loose) < 0; ++ } ++ ++ exports.eq = eq; ++ ++ function eq(a, b, loose) { ++ return compare(a, b, loose) === 0; ++ } ++ ++ exports.neq = neq; ++ ++ function neq(a, b, loose) { ++ return compare(a, b, loose) !== 0; ++ } ++ ++ exports.gte = gte; ++ ++ function gte(a, b, loose) { ++ return compare(a, b, loose) >= 0; ++ } ++ ++ exports.lte = lte; ++ ++ function lte(a, b, loose) { ++ return compare(a, b, loose) <= 0; ++ } ++ ++ exports.cmp = cmp; ++ ++ function cmp(a, op, b, loose) { ++ switch (op) { ++ case '===': ++ if (typeof a === 'object') a = a.version; ++ if (typeof b === 'object') b = b.version; ++ return a === b; ++ ++ case '!==': ++ if (typeof a === 'object') a = a.version; ++ if (typeof b === 'object') b = b.version; ++ return a !== b; ++ ++ case '': ++ case '=': ++ case '==': ++ return eq(a, b, loose); ++ ++ case '!=': ++ return neq(a, b, loose); ++ ++ case '>': ++ return gt(a, b, loose); ++ ++ case '>=': ++ return gte(a, b, loose); ++ ++ case '<': ++ return lt(a, b, loose); ++ ++ case '<=': ++ return lte(a, b, loose); ++ ++ default: ++ throw new TypeError('Invalid operator: ' + op); ++ } ++ } ++ ++ exports.Comparator = Comparator; ++ ++ function Comparator(comp, options) { ++ if (!options || typeof options !== 'object') { ++ options = { ++ loose: !!options, ++ includePrerelease: false ++ }; ++ } ++ ++ if (comp instanceof Comparator) { ++ if (comp.loose === !!options.loose) { ++ return comp; ++ } else { ++ comp = comp.value; ++ } ++ } ++ ++ if (!(this instanceof Comparator)) { ++ return new Comparator(comp, options); ++ } ++ ++ debug('comparator', comp, options); ++ this.options = options; ++ this.loose = !!options.loose; ++ this.parse(comp); ++ ++ if (this.semver === ANY) { ++ this.value = ''; ++ } else { ++ this.value = this.operator + this.semver.version; ++ } ++ ++ debug('comp', this); ++ } ++ ++ var ANY = {}; ++ ++ Comparator.prototype.parse = function (comp) { ++ var r = this.options.loose ? re[COMPARATORLOOSE] : re[COMPARATOR]; ++ var m = comp.match(r); ++ ++ if (!m) { ++ throw new TypeError('Invalid comparator: ' + comp); ++ } ++ ++ this.operator = m[1]; ++ ++ if (this.operator === '=') { ++ this.operator = ''; ++ } // if it literally is just '>' or '' then allow anything. ++ ++ ++ if (!m[2]) { ++ this.semver = ANY; ++ } else { ++ this.semver = new SemVer(m[2], this.options.loose); ++ } ++ }; ++ ++ Comparator.prototype.toString = function () { ++ return this.value; ++ }; ++ ++ Comparator.prototype.test = function (version) { ++ debug('Comparator.test', version, this.options.loose); ++ ++ if (this.semver === ANY) { ++ return true; ++ } ++ ++ if (typeof version === 'string') { ++ version = new SemVer(version, this.options); ++ } ++ ++ return cmp(version, this.operator, this.semver, this.options); ++ }; ++ ++ Comparator.prototype.intersects = function (comp, options) { ++ if (!(comp instanceof Comparator)) { ++ throw new TypeError('a Comparator is required'); ++ } ++ ++ if (!options || typeof options !== 'object') { ++ options = { ++ loose: !!options, ++ includePrerelease: false ++ }; ++ } ++ ++ var rangeTmp; ++ ++ if (this.operator === '') { ++ rangeTmp = new Range(comp.value, options); ++ return satisfies(this.value, rangeTmp, options); ++ } else if (comp.operator === '') { ++ rangeTmp = new Range(this.value, options); ++ return satisfies(comp.semver, rangeTmp, options); ++ } ++ ++ var sameDirectionIncreasing = (this.operator === '>=' || this.operator === '>') && (comp.operator === '>=' || comp.operator === '>'); ++ var sameDirectionDecreasing = (this.operator === '<=' || this.operator === '<') && (comp.operator === '<=' || comp.operator === '<'); ++ var sameSemVer = this.semver.version === comp.semver.version; ++ var differentDirectionsInclusive = (this.operator === '>=' || this.operator === '<=') && (comp.operator === '>=' || comp.operator === '<='); ++ var oppositeDirectionsLessThan = cmp(this.semver, '<', comp.semver, options) && (this.operator === '>=' || this.operator === '>') && (comp.operator === '<=' || comp.operator === '<'); ++ var oppositeDirectionsGreaterThan = cmp(this.semver, '>', comp.semver, options) && (this.operator === '<=' || this.operator === '<') && (comp.operator === '>=' || comp.operator === '>'); ++ return sameDirectionIncreasing || sameDirectionDecreasing || sameSemVer && differentDirectionsInclusive || oppositeDirectionsLessThan || oppositeDirectionsGreaterThan; ++ }; ++ ++ exports.Range = Range; ++ ++ function Range(range, options) { ++ if (!options || typeof options !== 'object') { ++ options = { ++ loose: !!options, ++ includePrerelease: false ++ }; ++ } ++ ++ if (range instanceof Range) { ++ if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) { ++ return range; ++ } else { ++ return new Range(range.raw, options); ++ } ++ } ++ ++ if (range instanceof Comparator) { ++ return new Range(range.value, options); ++ } ++ ++ if (!(this instanceof Range)) { ++ return new Range(range, options); ++ } ++ ++ this.options = options; ++ this.loose = !!options.loose; ++ this.includePrerelease = !!options.includePrerelease; // First, split based on boolean or || ++ ++ this.raw = range; ++ this.set = range.split(/\s*\|\|\s*/).map(function (range) { ++ return this.parseRange(range.trim()); ++ }, this).filter(function (c) { ++ // throw out any that are not relevant for whatever reason ++ return c.length; ++ }); ++ ++ if (!this.set.length) { ++ throw new TypeError('Invalid SemVer Range: ' + range); ++ } ++ ++ this.format(); ++ } ++ ++ Range.prototype.format = function () { ++ this.range = this.set.map(function (comps) { ++ return comps.join(' ').trim(); ++ }).join('||').trim(); ++ return this.range; ++ }; ++ ++ Range.prototype.toString = function () { ++ return this.range; ++ }; ++ ++ Range.prototype.parseRange = function (range) { ++ var loose = this.options.loose; ++ range = range.trim(); // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4` ++ ++ var hr = loose ? re[HYPHENRANGELOOSE] : re[HYPHENRANGE]; ++ range = range.replace(hr, hyphenReplace); ++ debug('hyphen replace', range); // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5` ++ ++ range = range.replace(re[COMPARATORTRIM], comparatorTrimReplace); ++ debug('comparator trim', range, re[COMPARATORTRIM]); // `~ 1.2.3` => `~1.2.3` ++ ++ range = range.replace(re[TILDETRIM], tildeTrimReplace); // `^ 1.2.3` => `^1.2.3` ++ ++ range = range.replace(re[CARETTRIM], caretTrimReplace); // normalize spaces ++ ++ range = range.split(/\s+/).join(' '); // At this point, the range is completely trimmed and ++ // ready to be split into comparators. ++ ++ var compRe = loose ? re[COMPARATORLOOSE] : re[COMPARATOR]; ++ var set = range.split(' ').map(function (comp) { ++ return parseComparator(comp, this.options); ++ }, this).join(' ').split(/\s+/); ++ ++ if (this.options.loose) { ++ // in loose mode, throw out any that are not valid comparators ++ set = set.filter(function (comp) { ++ return !!comp.match(compRe); ++ }); ++ } ++ ++ set = set.map(function (comp) { ++ return new Comparator(comp, this.options); ++ }, this); ++ return set; ++ }; ++ ++ Range.prototype.intersects = function (range, options) { ++ if (!(range instanceof Range)) { ++ throw new TypeError('a Range is required'); ++ } ++ ++ return this.set.some(function (thisComparators) { ++ return thisComparators.every(function (thisComparator) { ++ return range.set.some(function (rangeComparators) { ++ return rangeComparators.every(function (rangeComparator) { ++ return thisComparator.intersects(rangeComparator, options); ++ }); ++ }); ++ }); ++ }); ++ }; // Mostly just for testing and legacy API reasons ++ ++ ++ exports.toComparators = toComparators; ++ ++ function toComparators(range, options) { ++ return new Range(range, options).set.map(function (comp) { ++ return comp.map(function (c) { ++ return c.value; ++ }).join(' ').trim().split(' '); ++ }); ++ } // comprised of xranges, tildes, stars, and gtlt's at this point. ++ // already replaced the hyphen ranges ++ // turn into a set of JUST comparators. ++ ++ ++ function parseComparator(comp, options) { ++ debug('comp', comp, options); ++ comp = replaceCarets(comp, options); ++ debug('caret', comp); ++ comp = replaceTildes(comp, options); ++ debug('tildes', comp); ++ comp = replaceXRanges(comp, options); ++ debug('xrange', comp); ++ comp = replaceStars(comp, options); ++ debug('stars', comp); ++ return comp; ++ } ++ ++ function isX(id) { ++ return !id || id.toLowerCase() === 'x' || id === '*'; ++ } // ~, ~> --> * (any, kinda silly) ++ // ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0 ++ // ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0 ++ // ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0 ++ // ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0 ++ // ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0 ++ ++ ++ function replaceTildes(comp, options) { ++ return comp.trim().split(/\s+/).map(function (comp) { ++ return replaceTilde(comp, options); ++ }).join(' '); ++ } ++ ++ function replaceTilde(comp, options) { ++ var r = options.loose ? re[TILDELOOSE] : re[TILDE]; ++ return comp.replace(r, function (_, M, m, p, pr) { ++ debug('tilde', comp, _, M, m, p, pr); ++ var ret; ++ ++ if (isX(M)) { ++ ret = ''; ++ } else if (isX(m)) { ++ ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'; ++ } else if (isX(p)) { ++ // ~1.2 == >=1.2.0 <1.3.0 ++ ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'; ++ } else if (pr) { ++ debug('replaceTilde pr', pr); ++ ret = '>=' + M + '.' + m + '.' + p + '-' + pr + ' <' + M + '.' + (+m + 1) + '.0'; ++ } else { ++ // ~1.2.3 == >=1.2.3 <1.3.0 ++ ret = '>=' + M + '.' + m + '.' + p + ' <' + M + '.' + (+m + 1) + '.0'; ++ } ++ ++ debug('tilde return', ret); ++ return ret; ++ }); ++ } // ^ --> * (any, kinda silly) ++ // ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0 ++ // ^2.0, ^2.0.x --> >=2.0.0 <3.0.0 ++ // ^1.2, ^1.2.x --> >=1.2.0 <2.0.0 ++ // ^1.2.3 --> >=1.2.3 <2.0.0 ++ // ^1.2.0 --> >=1.2.0 <2.0.0 ++ ++ ++ function replaceCarets(comp, options) { ++ return comp.trim().split(/\s+/).map(function (comp) { ++ return replaceCaret(comp, options); ++ }).join(' '); ++ } ++ ++ function replaceCaret(comp, options) { ++ debug('caret', comp, options); ++ var r = options.loose ? re[CARETLOOSE] : re[CARET]; ++ return comp.replace(r, function (_, M, m, p, pr) { ++ debug('caret', comp, _, M, m, p, pr); ++ var ret; ++ ++ if (isX(M)) { ++ ret = ''; ++ } else if (isX(m)) { ++ ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'; ++ } else if (isX(p)) { ++ if (M === '0') { ++ ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'; ++ } else { ++ ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0'; ++ } ++ } else if (pr) { ++ debug('replaceCaret pr', pr); ++ ++ if (M === '0') { ++ if (m === '0') { ++ ret = '>=' + M + '.' + m + '.' + p + '-' + pr + ' <' + M + '.' + m + '.' + (+p + 1); ++ } else { ++ ret = '>=' + M + '.' + m + '.' + p + '-' + pr + ' <' + M + '.' + (+m + 1) + '.0'; ++ } ++ } else { ++ ret = '>=' + M + '.' + m + '.' + p + '-' + pr + ' <' + (+M + 1) + '.0.0'; ++ } ++ } else { ++ debug('no pr'); ++ ++ if (M === '0') { ++ if (m === '0') { ++ ret = '>=' + M + '.' + m + '.' + p + ' <' + M + '.' + m + '.' + (+p + 1); ++ } else { ++ ret = '>=' + M + '.' + m + '.' + p + ' <' + M + '.' + (+m + 1) + '.0'; ++ } ++ } else { ++ ret = '>=' + M + '.' + m + '.' + p + ' <' + (+M + 1) + '.0.0'; ++ } ++ } ++ ++ debug('caret return', ret); ++ return ret; ++ }); ++ } ++ ++ function replaceXRanges(comp, options) { ++ debug('replaceXRanges', comp, options); ++ return comp.split(/\s+/).map(function (comp) { ++ return replaceXRange(comp, options); ++ }).join(' '); ++ } ++ ++ function replaceXRange(comp, options) { ++ comp = comp.trim(); ++ var r = options.loose ? re[XRANGELOOSE] : re[XRANGE]; ++ return comp.replace(r, function (ret, gtlt, M, m, p, pr) { ++ debug('xRange', comp, ret, gtlt, M, m, p, pr); ++ var xM = isX(M); ++ var xm = xM || isX(m); ++ var xp = xm || isX(p); ++ var anyX = xp; ++ ++ if (gtlt === '=' && anyX) { ++ gtlt = ''; ++ } ++ ++ if (xM) { ++ if (gtlt === '>' || gtlt === '<') { ++ // nothing is allowed ++ ret = '<0.0.0'; ++ } else { ++ // nothing is forbidden ++ ret = '*'; ++ } ++ } else if (gtlt && anyX) { ++ // we know patch is an x, because we have any x at all. ++ // replace X with 0 ++ if (xm) { ++ m = 0; ++ } ++ ++ p = 0; ++ ++ if (gtlt === '>') { ++ // >1 => >=2.0.0 ++ // >1.2 => >=1.3.0 ++ // >1.2.3 => >= 1.2.4 ++ gtlt = '>='; ++ ++ if (xm) { ++ M = +M + 1; ++ m = 0; ++ p = 0; ++ } else { ++ m = +m + 1; ++ p = 0; ++ } ++ } else if (gtlt === '<=') { ++ // <=0.7.x is actually <0.8.0, since any 0.7.x should ++ // pass. Similarly, <=7.x is actually <8.0.0, etc. ++ gtlt = '<'; ++ ++ if (xm) { ++ M = +M + 1; ++ } else { ++ m = +m + 1; ++ } ++ } ++ ++ ret = gtlt + M + '.' + m + '.' + p; ++ } else if (xm) { ++ ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'; ++ } else if (xp) { ++ ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'; ++ } ++ ++ debug('xRange return', ret); ++ return ret; ++ }); ++ } // Because * is AND-ed with everything else in the comparator, ++ // and '' means "any version", just remove the *s entirely. ++ ++ ++ function replaceStars(comp, options) { ++ debug('replaceStars', comp, options); // Looseness is ignored here. star is always as loose as it gets! ++ ++ return comp.trim().replace(re[STAR], ''); ++ } // This function is passed to string.replace(re[HYPHENRANGE]) ++ // M, m, patch, prerelease, build ++ // 1.2 - 3.4.5 => >=1.2.0 <=3.4.5 ++ // 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do ++ // 1.2 - 3.4 => >=1.2.0 <3.5.0 ++ ++ ++ function hyphenReplace($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) { ++ if (isX(fM)) { ++ from = ''; ++ } else if (isX(fm)) { ++ from = '>=' + fM + '.0.0'; ++ } else if (isX(fp)) { ++ from = '>=' + fM + '.' + fm + '.0'; ++ } else { ++ from = '>=' + from; ++ } ++ ++ if (isX(tM)) { ++ to = ''; ++ } else if (isX(tm)) { ++ to = '<' + (+tM + 1) + '.0.0'; ++ } else if (isX(tp)) { ++ to = '<' + tM + '.' + (+tm + 1) + '.0'; ++ } else if (tpr) { ++ to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr; ++ } else { ++ to = '<=' + to; ++ } ++ ++ return (from + ' ' + to).trim(); ++ } // if ANY of the sets match ALL of its comparators, then pass ++ ++ ++ Range.prototype.test = function (version) { ++ if (!version) { ++ return false; ++ } ++ ++ if (typeof version === 'string') { ++ version = new SemVer(version, this.options); ++ } ++ ++ for (var i = 0; i < this.set.length; i++) { ++ if (testSet(this.set[i], version, this.options)) { ++ return true; ++ } ++ } ++ ++ return false; ++ }; ++ ++ function testSet(set, version, options) { ++ for (var i = 0; i < set.length; i++) { ++ if (!set[i].test(version)) { ++ return false; ++ } ++ } ++ ++ if (version.prerelease.length && !options.includePrerelease) { ++ // Find the set of versions that are allowed to have prereleases ++ // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0 ++ // That should allow `1.2.3-pr.2` to pass. ++ // However, `1.2.4-alpha.notready` should NOT be allowed, ++ // even though it's within the range set by the comparators. ++ for (i = 0; i < set.length; i++) { ++ debug(set[i].semver); ++ ++ if (set[i].semver === ANY) { ++ continue; ++ } ++ ++ if (set[i].semver.prerelease.length > 0) { ++ var allowed = set[i].semver; ++ ++ if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) { ++ return true; ++ } ++ } ++ } // Version has a -pre, but it's not one of the ones we like. ++ ++ ++ return false; ++ } ++ ++ return true; ++ } ++ ++ exports.satisfies = satisfies; ++ ++ function satisfies(version, range, options) { ++ try { ++ range = new Range(range, options); ++ } catch (er) { ++ return false; ++ } ++ ++ return range.test(version); ++ } ++ ++ exports.maxSatisfying = maxSatisfying; ++ ++ function maxSatisfying(versions, range, options) { ++ var max = null; ++ var maxSV = null; ++ ++ try { ++ var rangeObj = new Range(range, options); ++ } catch (er) { ++ return null; ++ } ++ ++ versions.forEach(function (v) { ++ if (rangeObj.test(v)) { ++ // satisfies(v, range, options) ++ if (!max || maxSV.compare(v) === -1) { ++ // compare(max, v, true) ++ max = v; ++ maxSV = new SemVer(max, options); ++ } ++ } ++ }); ++ return max; ++ } ++ ++ exports.minSatisfying = minSatisfying; ++ ++ function minSatisfying(versions, range, options) { ++ var min = null; ++ var minSV = null; ++ ++ try { ++ var rangeObj = new Range(range, options); ++ } catch (er) { ++ return null; ++ } ++ ++ versions.forEach(function (v) { ++ if (rangeObj.test(v)) { ++ // satisfies(v, range, options) ++ if (!min || minSV.compare(v) === 1) { ++ // compare(min, v, true) ++ min = v; ++ minSV = new SemVer(min, options); ++ } ++ } ++ }); ++ return min; ++ } ++ ++ exports.minVersion = minVersion; ++ ++ function minVersion(range, loose) { ++ range = new Range(range, loose); ++ var minver = new SemVer('0.0.0'); ++ ++ if (range.test(minver)) { ++ return minver; ++ } ++ ++ minver = new SemVer('0.0.0-0'); ++ ++ if (range.test(minver)) { ++ return minver; ++ } ++ ++ minver = null; ++ ++ for (var i = 0; i < range.set.length; ++i) { ++ var comparators = range.set[i]; ++ comparators.forEach(function (comparator) { ++ // Clone to avoid manipulating the comparator's semver object. ++ var compver = new SemVer(comparator.semver.version); ++ ++ switch (comparator.operator) { ++ case '>': ++ if (compver.prerelease.length === 0) { ++ compver.patch++; ++ } else { ++ compver.prerelease.push(0); ++ } ++ ++ compver.raw = compver.format(); ++ ++ /* fallthrough */ ++ ++ case '': ++ case '>=': ++ if (!minver || gt(minver, compver)) { ++ minver = compver; ++ } ++ ++ break; ++ ++ case '<': ++ case '<=': ++ /* Ignore maximum versions */ ++ break; ++ ++ /* istanbul ignore next */ ++ ++ default: ++ throw new Error('Unexpected operation: ' + comparator.operator); ++ } ++ }); ++ } ++ ++ if (minver && range.test(minver)) { ++ return minver; ++ } ++ ++ return null; ++ } ++ ++ exports.validRange = validRange; ++ ++ function validRange(range, options) { ++ try { ++ // Return '*' instead of '' so that truthiness works. ++ // This will throw if it's invalid anyway ++ return new Range(range, options).range || '*'; ++ } catch (er) { ++ return null; ++ } ++ } // Determine if version is less than all the versions possible in the range ++ ++ ++ exports.ltr = ltr; ++ ++ function ltr(version, range, options) { ++ return outside(version, range, '<', options); ++ } // Determine if version is greater than all the versions possible in the range. ++ ++ ++ exports.gtr = gtr; ++ ++ function gtr(version, range, options) { ++ return outside(version, range, '>', options); ++ } ++ ++ exports.outside = outside; ++ ++ function outside(version, range, hilo, options) { ++ version = new SemVer(version, options); ++ range = new Range(range, options); ++ var gtfn, ltefn, ltfn, comp, ecomp; ++ ++ switch (hilo) { ++ case '>': ++ gtfn = gt; ++ ltefn = lte; ++ ltfn = lt; ++ comp = '>'; ++ ecomp = '>='; ++ break; ++ ++ case '<': ++ gtfn = lt; ++ ltefn = gte; ++ ltfn = gt; ++ comp = '<'; ++ ecomp = '<='; ++ break; ++ ++ default: ++ throw new TypeError('Must provide a hilo val of "<" or ">"'); ++ } // If it satisifes the range it is not outside ++ ++ ++ if (satisfies(version, range, options)) { ++ return false; ++ } // From now on, variable terms are as if we're in "gtr" mode. ++ // but note that everything is flipped for the "ltr" function. ++ ++ ++ for (var i = 0; i < range.set.length; ++i) { ++ var comparators = range.set[i]; ++ var high = null; ++ var low = null; ++ comparators.forEach(function (comparator) { ++ if (comparator.semver === ANY) { ++ comparator = new Comparator('>=0.0.0'); ++ } ++ ++ high = high || comparator; ++ low = low || comparator; ++ ++ if (gtfn(comparator.semver, high.semver, options)) { ++ high = comparator; ++ } else if (ltfn(comparator.semver, low.semver, options)) { ++ low = comparator; ++ } ++ }); // If the edge version comparator has a operator then our version ++ // isn't outside it ++ ++ if (high.operator === comp || high.operator === ecomp) { ++ return false; ++ } // If the lowest version comparator has an operator and our version ++ // is less than it then it isn't higher than the range ++ ++ ++ if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) { ++ return false; ++ } else if (low.operator === ecomp && ltfn(version, low.semver)) { ++ return false; ++ } ++ } ++ ++ return true; ++ } ++ ++ exports.prerelease = prerelease; ++ ++ function prerelease(version, options) { ++ var parsed = parse(version, options); ++ return parsed && parsed.prerelease.length ? parsed.prerelease : null; ++ } ++ ++ exports.intersects = intersects; ++ ++ function intersects(r1, r2, options) { ++ r1 = new Range(r1, options); ++ r2 = new Range(r2, options); ++ return r1.intersects(r2); ++ } ++ ++ exports.coerce = coerce; ++ ++ function coerce(version) { ++ if (version instanceof SemVer) { ++ return version; ++ } ++ ++ if (typeof version !== 'string') { ++ return null; ++ } ++ ++ var match = version.match(re[COERCE]); ++ ++ if (match == null) { ++ return null; ++ } ++ ++ return parse(match[1] + '.' + (match[2] || '0') + '.' + (match[3] || '0')); ++ } ++}); ++var semver_1 = semver$2.SEMVER_SPEC_VERSION; ++var semver_2 = semver$2.re; ++var semver_3 = semver$2.src; ++var semver_4 = semver$2.parse; ++var semver_5 = semver$2.valid; ++var semver_6 = semver$2.clean; ++var semver_7 = semver$2.SemVer; ++var semver_8 = semver$2.inc; ++var semver_9 = semver$2.diff; ++var semver_10 = semver$2.compareIdentifiers; ++var semver_11 = semver$2.rcompareIdentifiers; ++var semver_12 = semver$2.major; ++var semver_13 = semver$2.minor; ++var semver_14 = semver$2.patch; ++var semver_15 = semver$2.compare; ++var semver_16 = semver$2.compareLoose; ++var semver_17 = semver$2.rcompare; ++var semver_18 = semver$2.sort; ++var semver_19 = semver$2.rsort; ++var semver_20 = semver$2.gt; ++var semver_21 = semver$2.lt; ++var semver_22 = semver$2.eq; ++var semver_23 = semver$2.neq; ++var semver_24 = semver$2.gte; ++var semver_25 = semver$2.lte; ++var semver_26 = semver$2.cmp; ++var semver_27 = semver$2.Comparator; ++var semver_28 = semver$2.Range; ++var semver_29 = semver$2.toComparators; ++var semver_30 = semver$2.satisfies; ++var semver_31 = semver$2.maxSatisfying; ++var semver_32 = semver$2.minSatisfying; ++var semver_33 = semver$2.minVersion; ++var semver_34 = semver$2.validRange; ++var semver_35 = semver$2.ltr; ++var semver_36 = semver$2.gtr; ++var semver_37 = semver$2.outside; ++var semver_38 = semver$2.prerelease; ++var semver_39 = semver$2.intersects; ++var semver_40 = semver$2.coerce; ++ ++var hasOwnProperty = Object.prototype.hasOwnProperty; ++var pseudomap = PseudoMap; ++ ++function PseudoMap(set) { ++ if (!(this instanceof PseudoMap)) // whyyyyyyy ++ throw new TypeError("Constructor PseudoMap requires 'new'"); ++ this.clear(); ++ ++ if (set) { ++ if (set instanceof PseudoMap || typeof Map === 'function' && set instanceof Map) set.forEach(function (value, key) { ++ this.set(key, value); ++ }, this);else if (Array.isArray(set)) set.forEach(function (kv) { ++ this.set(kv[0], kv[1]); ++ }, this);else throw new TypeError('invalid argument'); ++ } ++} ++ ++PseudoMap.prototype.forEach = function (fn, thisp) { ++ thisp = thisp || this; ++ Object.keys(this._data).forEach(function (k) { ++ if (k !== 'size') fn.call(thisp, this._data[k].value, this._data[k].key); ++ }, this); ++}; ++ ++PseudoMap.prototype.has = function (k) { ++ return !!find(this._data, k); ++}; ++ ++PseudoMap.prototype.get = function (k) { ++ var res = find(this._data, k); ++ return res && res.value; ++}; ++ ++PseudoMap.prototype.set = function (k, v) { ++ set(this._data, k, v); ++}; ++ ++PseudoMap.prototype.delete = function (k) { ++ var res = find(this._data, k); ++ ++ if (res) { ++ delete this._data[res._index]; ++ this._data.size--; ++ } ++}; ++ ++PseudoMap.prototype.clear = function () { ++ var data = Object.create(null); ++ data.size = 0; ++ Object.defineProperty(this, '_data', { ++ value: data, ++ enumerable: false, ++ configurable: true, ++ writable: false ++ }); ++}; ++ ++Object.defineProperty(PseudoMap.prototype, 'size', { ++ get: function () { ++ return this._data.size; ++ }, ++ set: function (n) {}, ++ enumerable: true, ++ configurable: true ++}); ++ ++PseudoMap.prototype.values = PseudoMap.prototype.keys = PseudoMap.prototype.entries = function () { ++ throw new Error('iterators are not implemented in this version'); ++}; // Either identical, or both NaN ++ ++ ++function same(a, b) { ++ return a === b || a !== a && b !== b; ++} ++ ++function Entry(k, v, i) { ++ this.key = k; ++ this.value = v; ++ this._index = i; ++} ++ ++function find(data, k) { ++ for (var i = 0, s = '_' + k, key = s; hasOwnProperty.call(data, key); key = s + i++) { ++ if (same(data[key].key, k)) return data[key]; ++ } ++} ++ ++function set(data, k, v) { ++ for (var i = 0, s = '_' + k, key = s; hasOwnProperty.call(data, key); key = s + i++) { ++ if (same(data[key].key, k)) { ++ data[key].value = v; ++ return; ++ } ++ } ++ ++ data.size++; ++ data[key] = new Entry(k, v, key); ++} ++ ++var map = createCommonjsModule(function (module) { ++ if (process.env.npm_package_name === 'pseudomap' && process.env.npm_lifecycle_script === 'test') process.env.TEST_PSEUDOMAP = 'true'; ++ ++ if (typeof Map === 'function' && !process.env.TEST_PSEUDOMAP) { ++ module.exports = Map; ++ } else { ++ module.exports = pseudomap; ++ } ++}); ++ ++var yallist = Yallist; ++Yallist.Node = Node; ++Yallist.create = Yallist; ++ ++function Yallist(list) { ++ var self = this; ++ ++ if (!(self instanceof Yallist)) { ++ self = new Yallist(); ++ } ++ ++ self.tail = null; ++ self.head = null; ++ self.length = 0; ++ ++ if (list && typeof list.forEach === 'function') { ++ list.forEach(function (item) { ++ self.push(item); ++ }); ++ } else if (arguments.length > 0) { ++ for (var i = 0, l = arguments.length; i < l; i++) { ++ self.push(arguments[i]); ++ } ++ } ++ ++ return self; ++} ++ ++Yallist.prototype.removeNode = function (node) { ++ if (node.list !== this) { ++ throw new Error('removing node which does not belong to this list'); ++ } ++ ++ var next = node.next; ++ var prev = node.prev; ++ ++ if (next) { ++ next.prev = prev; ++ } ++ ++ if (prev) { ++ prev.next = next; ++ } ++ ++ if (node === this.head) { ++ this.head = next; ++ } ++ ++ if (node === this.tail) { ++ this.tail = prev; ++ } ++ ++ node.list.length--; ++ node.next = null; ++ node.prev = null; ++ node.list = null; ++}; ++ ++Yallist.prototype.unshiftNode = function (node) { ++ if (node === this.head) { ++ return; ++ } ++ ++ if (node.list) { ++ node.list.removeNode(node); ++ } ++ ++ var head = this.head; ++ node.list = this; ++ node.next = head; ++ ++ if (head) { ++ head.prev = node; ++ } ++ ++ this.head = node; ++ ++ if (!this.tail) { ++ this.tail = node; ++ } ++ ++ this.length++; ++}; ++ ++Yallist.prototype.pushNode = function (node) { ++ if (node === this.tail) { ++ return; ++ } ++ ++ if (node.list) { ++ node.list.removeNode(node); ++ } ++ ++ var tail = this.tail; ++ node.list = this; ++ node.prev = tail; ++ ++ if (tail) { ++ tail.next = node; ++ } ++ ++ this.tail = node; ++ ++ if (!this.head) { ++ this.head = node; ++ } ++ ++ this.length++; ++}; ++ ++Yallist.prototype.push = function () { ++ for (var i = 0, l = arguments.length; i < l; i++) { ++ push(this, arguments[i]); ++ } ++ ++ return this.length; ++}; ++ ++Yallist.prototype.unshift = function () { ++ for (var i = 0, l = arguments.length; i < l; i++) { ++ unshift(this, arguments[i]); ++ } ++ ++ return this.length; ++}; ++ ++Yallist.prototype.pop = function () { ++ if (!this.tail) { ++ return undefined; ++ } ++ ++ var res = this.tail.value; ++ this.tail = this.tail.prev; ++ ++ if (this.tail) { ++ this.tail.next = null; ++ } else { ++ this.head = null; ++ } ++ ++ this.length--; ++ return res; ++}; ++ ++Yallist.prototype.shift = function () { ++ if (!this.head) { ++ return undefined; ++ } ++ ++ var res = this.head.value; ++ this.head = this.head.next; ++ ++ if (this.head) { ++ this.head.prev = null; ++ } else { ++ this.tail = null; ++ } ++ ++ this.length--; ++ return res; ++}; ++ ++Yallist.prototype.forEach = function (fn, thisp) { ++ thisp = thisp || this; ++ ++ for (var walker = this.head, i = 0; walker !== null; i++) { ++ fn.call(thisp, walker.value, i, this); ++ walker = walker.next; ++ } ++}; ++ ++Yallist.prototype.forEachReverse = function (fn, thisp) { ++ thisp = thisp || this; ++ ++ for (var walker = this.tail, i = this.length - 1; walker !== null; i--) { ++ fn.call(thisp, walker.value, i, this); ++ walker = walker.prev; ++ } ++}; ++ ++Yallist.prototype.get = function (n) { ++ for (var i = 0, walker = this.head; walker !== null && i < n; i++) { ++ // abort out of the list early if we hit a cycle ++ walker = walker.next; ++ } ++ ++ if (i === n && walker !== null) { ++ return walker.value; ++ } ++}; ++ ++Yallist.prototype.getReverse = function (n) { ++ for (var i = 0, walker = this.tail; walker !== null && i < n; i++) { ++ // abort out of the list early if we hit a cycle ++ walker = walker.prev; ++ } ++ ++ if (i === n && walker !== null) { ++ return walker.value; ++ } ++}; ++ ++Yallist.prototype.map = function (fn, thisp) { ++ thisp = thisp || this; ++ var res = new Yallist(); ++ ++ for (var walker = this.head; walker !== null;) { ++ res.push(fn.call(thisp, walker.value, this)); ++ walker = walker.next; ++ } ++ ++ return res; ++}; ++ ++Yallist.prototype.mapReverse = function (fn, thisp) { ++ thisp = thisp || this; ++ var res = new Yallist(); ++ ++ for (var walker = this.tail; walker !== null;) { ++ res.push(fn.call(thisp, walker.value, this)); ++ walker = walker.prev; ++ } ++ ++ return res; ++}; ++ ++Yallist.prototype.reduce = function (fn, initial) { ++ var acc; ++ var walker = this.head; ++ ++ if (arguments.length > 1) { ++ acc = initial; ++ } else if (this.head) { ++ walker = this.head.next; ++ acc = this.head.value; ++ } else { ++ throw new TypeError('Reduce of empty list with no initial value'); ++ } ++ ++ for (var i = 0; walker !== null; i++) { ++ acc = fn(acc, walker.value, i); ++ walker = walker.next; ++ } ++ ++ return acc; ++}; ++ ++Yallist.prototype.reduceReverse = function (fn, initial) { ++ var acc; ++ var walker = this.tail; ++ ++ if (arguments.length > 1) { ++ acc = initial; ++ } else if (this.tail) { ++ walker = this.tail.prev; ++ acc = this.tail.value; ++ } else { ++ throw new TypeError('Reduce of empty list with no initial value'); ++ } ++ ++ for (var i = this.length - 1; walker !== null; i--) { ++ acc = fn(acc, walker.value, i); ++ walker = walker.prev; ++ } ++ ++ return acc; ++}; ++ ++Yallist.prototype.toArray = function () { ++ var arr = new Array(this.length); ++ ++ for (var i = 0, walker = this.head; walker !== null; i++) { ++ arr[i] = walker.value; ++ walker = walker.next; ++ } ++ ++ return arr; ++}; ++ ++Yallist.prototype.toArrayReverse = function () { ++ var arr = new Array(this.length); ++ ++ for (var i = 0, walker = this.tail; walker !== null; i++) { ++ arr[i] = walker.value; ++ walker = walker.prev; ++ } ++ ++ return arr; ++}; ++ ++Yallist.prototype.slice = function (from, to) { ++ to = to || this.length; ++ ++ if (to < 0) { ++ to += this.length; ++ } ++ ++ from = from || 0; ++ ++ if (from < 0) { ++ from += this.length; ++ } ++ ++ var ret = new Yallist(); ++ ++ if (to < from || to < 0) { ++ return ret; ++ } ++ ++ if (from < 0) { ++ from = 0; ++ } ++ ++ if (to > this.length) { ++ to = this.length; ++ } ++ ++ for (var i = 0, walker = this.head; walker !== null && i < from; i++) { ++ walker = walker.next; ++ } ++ ++ for (; walker !== null && i < to; i++, walker = walker.next) { ++ ret.push(walker.value); ++ } ++ ++ return ret; ++}; ++ ++Yallist.prototype.sliceReverse = function (from, to) { ++ to = to || this.length; ++ ++ if (to < 0) { ++ to += this.length; ++ } ++ ++ from = from || 0; ++ ++ if (from < 0) { ++ from += this.length; ++ } ++ ++ var ret = new Yallist(); ++ ++ if (to < from || to < 0) { ++ return ret; ++ } ++ ++ if (from < 0) { ++ from = 0; ++ } ++ ++ if (to > this.length) { ++ to = this.length; ++ } ++ ++ for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) { ++ walker = walker.prev; ++ } ++ ++ for (; walker !== null && i > from; i--, walker = walker.prev) { ++ ret.push(walker.value); ++ } ++ ++ return ret; ++}; ++ ++Yallist.prototype.reverse = function () { ++ var head = this.head; ++ var tail = this.tail; ++ ++ for (var walker = head; walker !== null; walker = walker.prev) { ++ var p = walker.prev; ++ walker.prev = walker.next; ++ walker.next = p; ++ } ++ ++ this.head = tail; ++ this.tail = head; ++ return this; ++}; ++ ++function push(self, item) { ++ self.tail = new Node(item, self.tail, null, self); ++ ++ if (!self.head) { ++ self.head = self.tail; ++ } ++ ++ self.length++; ++} ++ ++function unshift(self, item) { ++ self.head = new Node(item, null, self.head, self); ++ ++ if (!self.tail) { ++ self.tail = self.head; ++ } ++ ++ self.length++; ++} ++ ++function Node(value, prev, next, list) { ++ if (!(this instanceof Node)) { ++ return new Node(value, prev, next, list); ++ } ++ ++ this.list = list; ++ this.value = value; ++ ++ if (prev) { ++ prev.next = this; ++ this.prev = prev; ++ } else { ++ this.prev = null; ++ } ++ ++ if (next) { ++ next.prev = this; ++ this.next = next; ++ } else { ++ this.next = null; ++ } ++} ++ ++var lruCache = LRUCache; // This will be a proper iterable 'Map' in engines that support it, ++// or a fakey-fake PseudoMap in older versions. ++// A linked list to keep track of recently-used-ness ++// use symbols if possible, otherwise just _props ++ ++var hasSymbol = typeof Symbol === 'function' && process.env._nodeLRUCacheForceNoSymbol !== '1'; ++var makeSymbol; ++ ++if (hasSymbol) { ++ makeSymbol = function (key) { ++ return Symbol(key); ++ }; ++} else { ++ makeSymbol = function (key) { ++ return '_' + key; ++ }; ++} ++ ++var MAX = makeSymbol('max'); ++var LENGTH = makeSymbol('length'); ++var LENGTH_CALCULATOR = makeSymbol('lengthCalculator'); ++var ALLOW_STALE = makeSymbol('allowStale'); ++var MAX_AGE = makeSymbol('maxAge'); ++var DISPOSE = makeSymbol('dispose'); ++var NO_DISPOSE_ON_SET = makeSymbol('noDisposeOnSet'); ++var LRU_LIST = makeSymbol('lruList'); ++var CACHE = makeSymbol('cache'); ++ ++function naiveLength() { ++ return 1; ++} // lruList is a yallist where the head is the youngest ++// item, and the tail is the oldest. the list contains the Hit ++// objects as the entries. ++// Each Hit object has a reference to its Yallist.Node. This ++// never changes. ++// ++// cache is a Map (or PseudoMap) that matches the keys to ++// the Yallist.Node object. ++ ++ ++function LRUCache(options) { ++ if (!(this instanceof LRUCache)) { ++ return new LRUCache(options); ++ } ++ ++ if (typeof options === 'number') { ++ options = { ++ max: options ++ }; ++ } ++ ++ if (!options) { ++ options = {}; ++ } ++ ++ var max = this[MAX] = options.max; // Kind of weird to have a default max of Infinity, but oh well. ++ ++ if (!max || !(typeof max === 'number') || max <= 0) { ++ this[MAX] = Infinity; ++ } ++ ++ var lc = options.length || naiveLength; ++ ++ if (typeof lc !== 'function') { ++ lc = naiveLength; ++ } ++ ++ this[LENGTH_CALCULATOR] = lc; ++ this[ALLOW_STALE] = options.stale || false; ++ this[MAX_AGE] = options.maxAge || 0; ++ this[DISPOSE] = options.dispose; ++ this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false; ++ this.reset(); ++} // resize the cache when the max changes. ++ ++ ++Object.defineProperty(LRUCache.prototype, 'max', { ++ set: function (mL) { ++ if (!mL || !(typeof mL === 'number') || mL <= 0) { ++ mL = Infinity; ++ } ++ ++ this[MAX] = mL; ++ trim$2(this); ++ }, ++ get: function () { ++ return this[MAX]; ++ }, ++ enumerable: true ++}); ++Object.defineProperty(LRUCache.prototype, 'allowStale', { ++ set: function (allowStale) { ++ this[ALLOW_STALE] = !!allowStale; ++ }, ++ get: function () { ++ return this[ALLOW_STALE]; ++ }, ++ enumerable: true ++}); ++Object.defineProperty(LRUCache.prototype, 'maxAge', { ++ set: function (mA) { ++ if (!mA || !(typeof mA === 'number') || mA < 0) { ++ mA = 0; ++ } ++ ++ this[MAX_AGE] = mA; ++ trim$2(this); ++ }, ++ get: function () { ++ return this[MAX_AGE]; ++ }, ++ enumerable: true ++}); // resize the cache when the lengthCalculator changes. ++ ++Object.defineProperty(LRUCache.prototype, 'lengthCalculator', { ++ set: function (lC) { ++ if (typeof lC !== 'function') { ++ lC = naiveLength; ++ } ++ ++ if (lC !== this[LENGTH_CALCULATOR]) { ++ this[LENGTH_CALCULATOR] = lC; ++ this[LENGTH] = 0; ++ this[LRU_LIST].forEach(function (hit) { ++ hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key); ++ this[LENGTH] += hit.length; ++ }, this); ++ } ++ ++ trim$2(this); ++ }, ++ get: function () { ++ return this[LENGTH_CALCULATOR]; ++ }, ++ enumerable: true ++}); ++Object.defineProperty(LRUCache.prototype, 'length', { ++ get: function () { ++ return this[LENGTH]; ++ }, ++ enumerable: true ++}); ++Object.defineProperty(LRUCache.prototype, 'itemCount', { ++ get: function () { ++ return this[LRU_LIST].length; ++ }, ++ enumerable: true ++}); ++ ++LRUCache.prototype.rforEach = function (fn, thisp) { ++ thisp = thisp || this; ++ ++ for (var walker = this[LRU_LIST].tail; walker !== null;) { ++ var prev = walker.prev; ++ forEachStep(this, fn, walker, thisp); ++ walker = prev; ++ } ++}; ++ ++function forEachStep(self, fn, node, thisp) { ++ var hit = node.value; ++ ++ if (isStale(self, hit)) { ++ del(self, node); ++ ++ if (!self[ALLOW_STALE]) { ++ hit = undefined; ++ } ++ } ++ ++ if (hit) { ++ fn.call(thisp, hit.value, hit.key, self); ++ } ++} ++ ++LRUCache.prototype.forEach = function (fn, thisp) { ++ thisp = thisp || this; ++ ++ for (var walker = this[LRU_LIST].head; walker !== null;) { ++ var next = walker.next; ++ forEachStep(this, fn, walker, thisp); ++ walker = next; ++ } ++}; ++ ++LRUCache.prototype.keys = function () { ++ return this[LRU_LIST].toArray().map(function (k) { ++ return k.key; ++ }, this); ++}; ++ ++LRUCache.prototype.values = function () { ++ return this[LRU_LIST].toArray().map(function (k) { ++ return k.value; ++ }, this); ++}; ++ ++LRUCache.prototype.reset = function () { ++ if (this[DISPOSE] && this[LRU_LIST] && this[LRU_LIST].length) { ++ this[LRU_LIST].forEach(function (hit) { ++ this[DISPOSE](hit.key, hit.value); ++ }, this); ++ } ++ ++ this[CACHE] = new map(); // hash of items by key ++ ++ this[LRU_LIST] = new yallist(); // list of items in order of use recency ++ ++ this[LENGTH] = 0; // length of items in the list ++}; ++ ++LRUCache.prototype.dump = function () { ++ return this[LRU_LIST].map(function (hit) { ++ if (!isStale(this, hit)) { ++ return { ++ k: hit.key, ++ v: hit.value, ++ e: hit.now + (hit.maxAge || 0) ++ }; ++ } ++ }, this).toArray().filter(function (h) { ++ return h; ++ }); ++}; ++ ++LRUCache.prototype.dumpLru = function () { ++ return this[LRU_LIST]; ++}; ++/* istanbul ignore next */ ++ ++ ++LRUCache.prototype.inspect = function (n, opts) { ++ var str = 'LRUCache {'; ++ var extras = false; ++ var as = this[ALLOW_STALE]; ++ ++ if (as) { ++ str += '\n allowStale: true'; ++ extras = true; ++ } ++ ++ var max = this[MAX]; ++ ++ if (max && max !== Infinity) { ++ if (extras) { ++ str += ','; ++ } ++ ++ str += '\n max: ' + util$3.inspect(max, opts); ++ extras = true; ++ } ++ ++ var maxAge = this[MAX_AGE]; ++ ++ if (maxAge) { ++ if (extras) { ++ str += ','; ++ } ++ ++ str += '\n maxAge: ' + util$3.inspect(maxAge, opts); ++ extras = true; ++ } ++ ++ var lc = this[LENGTH_CALCULATOR]; ++ ++ if (lc && lc !== naiveLength) { ++ if (extras) { ++ str += ','; ++ } ++ ++ str += '\n length: ' + util$3.inspect(this[LENGTH], opts); ++ extras = true; ++ } ++ ++ var didFirst = false; ++ this[LRU_LIST].forEach(function (item) { ++ if (didFirst) { ++ str += ',\n '; ++ } else { ++ if (extras) { ++ str += ',\n'; ++ } ++ ++ didFirst = true; ++ str += '\n '; ++ } ++ ++ var key = util$3.inspect(item.key).split('\n').join('\n '); ++ var val = { ++ value: item.value ++ }; ++ ++ if (item.maxAge !== maxAge) { ++ val.maxAge = item.maxAge; ++ } ++ ++ if (lc !== naiveLength) { ++ val.length = item.length; ++ } ++ ++ if (isStale(this, item)) { ++ val.stale = true; ++ } ++ ++ val = util$3.inspect(val, opts).split('\n').join('\n '); ++ str += key + ' => ' + val; ++ }); ++ ++ if (didFirst || extras) { ++ str += '\n'; ++ } ++ ++ str += '}'; ++ return str; ++}; ++ ++LRUCache.prototype.set = function (key, value, maxAge) { ++ maxAge = maxAge || this[MAX_AGE]; ++ var now = maxAge ? Date.now() : 0; ++ var len = this[LENGTH_CALCULATOR](value, key); ++ ++ if (this[CACHE].has(key)) { ++ if (len > this[MAX]) { ++ del(this, this[CACHE].get(key)); ++ return false; ++ } ++ ++ var node = this[CACHE].get(key); ++ var item = node.value; // dispose of the old one before overwriting ++ // split out into 2 ifs for better coverage tracking ++ ++ if (this[DISPOSE]) { ++ if (!this[NO_DISPOSE_ON_SET]) { ++ this[DISPOSE](key, item.value); ++ } ++ } ++ ++ item.now = now; ++ item.maxAge = maxAge; ++ item.value = value; ++ this[LENGTH] += len - item.length; ++ item.length = len; ++ this.get(key); ++ trim$2(this); ++ return true; ++ } ++ ++ var hit = new Entry$1(key, value, len, now, maxAge); // oversized objects fall out of cache automatically. ++ ++ if (hit.length > this[MAX]) { ++ if (this[DISPOSE]) { ++ this[DISPOSE](key, value); ++ } ++ ++ return false; ++ } ++ ++ this[LENGTH] += hit.length; ++ this[LRU_LIST].unshift(hit); ++ this[CACHE].set(key, this[LRU_LIST].head); ++ trim$2(this); ++ return true; ++}; ++ ++LRUCache.prototype.has = function (key) { ++ if (!this[CACHE].has(key)) return false; ++ var hit = this[CACHE].get(key).value; ++ ++ if (isStale(this, hit)) { ++ return false; ++ } ++ ++ return true; ++}; ++ ++LRUCache.prototype.get = function (key) { ++ return get(this, key, true); ++}; ++ ++LRUCache.prototype.peek = function (key) { ++ return get(this, key, false); ++}; ++ ++LRUCache.prototype.pop = function () { ++ var node = this[LRU_LIST].tail; ++ if (!node) return null; ++ del(this, node); ++ return node.value; ++}; ++ ++LRUCache.prototype.del = function (key) { ++ del(this, this[CACHE].get(key)); ++}; ++ ++LRUCache.prototype.load = function (arr) { ++ // reset the cache ++ this.reset(); ++ var now = Date.now(); // A previous serialized cache has the most recent items first ++ ++ for (var l = arr.length - 1; l >= 0; l--) { ++ var hit = arr[l]; ++ var expiresAt = hit.e || 0; ++ ++ if (expiresAt === 0) { ++ // the item was created without expiration in a non aged cache ++ this.set(hit.k, hit.v); ++ } else { ++ var maxAge = expiresAt - now; // dont add already expired items ++ ++ if (maxAge > 0) { ++ this.set(hit.k, hit.v, maxAge); ++ } ++ } ++ } ++}; ++ ++LRUCache.prototype.prune = function () { ++ var self = this; ++ this[CACHE].forEach(function (value, key) { ++ get(self, key, false); ++ }); ++}; ++ ++function get(self, key, doUse) { ++ var node = self[CACHE].get(key); ++ ++ if (node) { ++ var hit = node.value; ++ ++ if (isStale(self, hit)) { ++ del(self, node); ++ if (!self[ALLOW_STALE]) hit = undefined; ++ } else { ++ if (doUse) { ++ self[LRU_LIST].unshiftNode(node); ++ } ++ } ++ ++ if (hit) hit = hit.value; ++ } ++ ++ return hit; ++} ++ ++function isStale(self, hit) { ++ if (!hit || !hit.maxAge && !self[MAX_AGE]) { ++ return false; ++ } ++ ++ var stale = false; ++ var diff = Date.now() - hit.now; ++ ++ if (hit.maxAge) { ++ stale = diff > hit.maxAge; ++ } else { ++ stale = self[MAX_AGE] && diff > self[MAX_AGE]; ++ } ++ ++ return stale; ++} ++ ++function trim$2(self) { ++ if (self[LENGTH] > self[MAX]) { ++ for (var walker = self[LRU_LIST].tail; self[LENGTH] > self[MAX] && walker !== null;) { ++ // We know that we're about to delete this one, and also ++ // what the next least recently used key will be, so just ++ // go ahead and set it now. ++ var prev = walker.prev; ++ del(self, walker); ++ walker = prev; ++ } ++ } ++} ++ ++function del(self, node) { ++ if (node) { ++ var hit = node.value; ++ ++ if (self[DISPOSE]) { ++ self[DISPOSE](hit.key, hit.value); ++ } ++ ++ self[LENGTH] -= hit.length; ++ self[CACHE].delete(hit.key); ++ self[LRU_LIST].removeNode(node); ++ } ++} // classy, since V8 prefers predictable objects. ++ ++ ++function Entry$1(key, value, length, now, maxAge) { ++ this.key = key; ++ this.value = value; ++ this.length = length; ++ this.now = now; ++ this.maxAge = maxAge || 0; ++} ++ ++var sigmund_1 = sigmund; ++ ++function sigmund(subject, maxSessions) { ++ maxSessions = maxSessions || 10; ++ var notes = []; ++ var analysis = ''; ++ var RE = RegExp; ++ ++ function psychoAnalyze(subject, session) { ++ if (session > maxSessions) return; ++ ++ if (typeof subject === 'function' || typeof subject === 'undefined') { ++ return; ++ } ++ ++ if (typeof subject !== 'object' || !subject || subject instanceof RE) { ++ analysis += subject; ++ return; ++ } ++ ++ if (notes.indexOf(subject) !== -1 || session === maxSessions) return; ++ notes.push(subject); ++ analysis += '{'; ++ Object.keys(subject).forEach(function (issue, _, __) { ++ // pseudo-private values. skip those. ++ if (issue.charAt(0) === '_') return; ++ var to = typeof subject[issue]; ++ if (to === 'function' || to === 'undefined') return; ++ analysis += issue; ++ psychoAnalyze(subject[issue], session + 1); ++ }); ++ } ++ ++ psychoAnalyze(subject, 0); ++ return analysis; ++} // vim: set softtabstop=4 shiftwidth=4: ++ ++var fnmatch = createCommonjsModule(function (module, exports) { ++ // Based on minimatch.js by isaacs ++ var platform = typeof process === "object" ? process.platform : "win32"; ++ if (module) module.exports = minimatch;else exports.minimatch = minimatch; ++ minimatch.Minimatch = Minimatch; ++ var cache = minimatch.cache = new lruCache({ ++ max: 100 ++ }), ++ GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {}; ++ var qmark = "[^/]" // * => any number of characters ++ , ++ 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. ++ , ++ twoStarDot = "(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?" // not a ^ or / followed by a dot, ++ // followed by anything, any number of times. ++ , ++ twoStarNoDot = "(?:(?!(?:\\\/|^)\\.).)*?" // characters that need to be escaped in RegExp. ++ , ++ reSpecials = charSet("().*{}+?[]^$\\!"); // "abc" -> { a:true, b:true, c:true } ++ ++ function charSet(s) { ++ return s.split("").reduce(function (set, c) { ++ set[c] = true; ++ return set; ++ }, {}); ++ } // normalizes slashes. ++ ++ ++ var slashSplit = /\/+/; ++ minimatch.monkeyPatch = monkeyPatch; ++ ++ function monkeyPatch() { ++ var desc = Object.getOwnPropertyDescriptor(String.prototype, "match"); ++ var orig = desc.value; ++ ++ desc.value = function (p) { ++ if (p instanceof Minimatch) return p.match(this); ++ return orig.call(this, p); ++ }; ++ ++ Object.defineProperty(String.prototype, desc); ++ } ++ ++ minimatch.filter = filter; ++ ++ function filter(pattern, options) { ++ options = options || {}; ++ return function (p, i, list) { ++ return minimatch(p, pattern, options); ++ }; ++ } ++ ++ function ext(a, b) { ++ a = a || {}; ++ b = b || {}; ++ var t = {}; ++ Object.keys(b).forEach(function (k) { ++ t[k] = b[k]; ++ }); ++ Object.keys(a).forEach(function (k) { ++ t[k] = a[k]; ++ }); ++ return t; ++ } ++ ++ minimatch.defaults = function (def) { ++ if (!def || !Object.keys(def).length) return minimatch; ++ var orig = minimatch; ++ ++ var m = function minimatch(p, pattern, options) { ++ return orig.minimatch(p, pattern, ext(def, options)); ++ }; ++ ++ m.Minimatch = function Minimatch(pattern, options) { ++ return new orig.Minimatch(pattern, ext(def, options)); ++ }; ++ ++ return m; ++ }; ++ ++ Minimatch.defaults = function (def) { ++ if (!def || !Object.keys(def).length) return Minimatch; ++ return minimatch.defaults(def).Minimatch; ++ }; ++ ++ function minimatch(p, pattern, options) { ++ if (typeof pattern !== "string") { ++ throw new TypeError("glob pattern string required"); ++ } ++ ++ if (!options) options = {}; // shortcut: comments match nothing. ++ ++ if (!options.nocomment && pattern.charAt(0) === "#") { ++ return false; ++ } // "" only matches "" ++ ++ ++ if (pattern.trim() === "") return p === ""; ++ return new Minimatch(pattern, options).match(p); ++ } ++ ++ function Minimatch(pattern, options) { ++ if (!(this instanceof Minimatch)) { ++ return new Minimatch(pattern, options, cache); ++ } ++ ++ if (typeof pattern !== "string") { ++ throw new TypeError("glob pattern string required"); ++ } ++ ++ if (!options) options = {}; // windows: need to use /, not \ ++ // On other platforms, \ is a valid (albeit bad) filename char. ++ ++ if (platform === "win32") { ++ pattern = pattern.split("\\").join("/"); ++ } // lru storage. ++ // these things aren't particularly big, but walking down the string ++ // and turning it into a regexp can get pretty costly. ++ ++ ++ var cacheKey = pattern + "\n" + sigmund_1(options); ++ var cached = minimatch.cache.get(cacheKey); ++ if (cached) return cached; ++ minimatch.cache.set(cacheKey, this); ++ this.options = options; ++ this.set = []; ++ this.pattern = pattern; ++ this.regexp = null; ++ this.negate = false; ++ this.comment = false; ++ this.empty = false; // make the set of regexps etc. ++ ++ this.make(); ++ } ++ ++ Minimatch.prototype.make = make; ++ ++ function make() { ++ // don't do it more than once. ++ if (this._made) return; ++ var pattern = this.pattern; ++ var 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 ++ ++ var set = this.globSet = this.braceExpand(); ++ if (options.debug) console.error(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(function (s) { ++ return s.split(slashSplit); ++ }); ++ if (options.debug) console.error(this.pattern, set); // glob --> regexps ++ ++ set = set.map(function (s, si, set) { ++ return s.map(this.parse, this); ++ }, this); ++ if (options.debug) console.error(this.pattern, set); // filter out everything that didn't compile properly. ++ ++ set = set.filter(function (s) { ++ return -1 === s.indexOf(false); ++ }); ++ if (options.debug) console.error(this.pattern, set); ++ this.set = set; ++ } ++ ++ Minimatch.prototype.parseNegate = parseNegate; ++ ++ function parseNegate() { ++ var pattern = this.pattern, ++ negate = false, ++ options = this.options, ++ negateOffset = 0; ++ if (options.nonegate) return; ++ ++ for (var i = 0, l = pattern.length; i < l && pattern.charAt(i) === "!"; i++) { ++ negate = !negate; ++ negateOffset++; ++ } ++ ++ if (negateOffset) this.pattern = pattern.substr(negateOffset); ++ this.negate = negate; ++ } // 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 = function (pattern, options) { ++ return new Minimatch(pattern, options).braceExpand(); ++ }; ++ ++ Minimatch.prototype.braceExpand = braceExpand; ++ ++ function braceExpand(pattern, options) { ++ options = options || this.options; ++ pattern = typeof pattern === "undefined" ? this.pattern : pattern; ++ ++ if (typeof pattern === "undefined") { ++ throw new Error("undefined pattern"); ++ } ++ ++ if (options.nobrace || !pattern.match(/\{.*\}/)) { ++ // shortcut. no need to expand. ++ return [pattern]; ++ } ++ ++ var escaping = false; // examples and comments refer to this crazy pattern: ++ // a{b,c{d,e},{f,g}h}x{y,z} ++ // expected: ++ // abxy ++ // abxz ++ // acdxy ++ // acdxz ++ // acexy ++ // acexz ++ // afhxy ++ // afhxz ++ // aghxy ++ // aghxz ++ // everything before the first \{ is just a prefix. ++ // So, we pluck that off, and work with the rest, ++ // and then prepend it to everything we find. ++ ++ if (pattern.charAt(0) !== "{") { ++ // console.error(pattern) ++ var prefix = null; ++ ++ for (var i = 0, l = pattern.length; i < l; i++) { ++ var c = pattern.charAt(i); // console.error(i, c) ++ ++ if (c === "\\") { ++ escaping = !escaping; ++ } else if (c === "{" && !escaping) { ++ prefix = pattern.substr(0, i); ++ break; ++ } ++ } // actually no sets, all { were escaped. ++ ++ ++ if (prefix === null) { ++ // console.error("no sets") ++ return [pattern]; ++ } ++ ++ var tail = braceExpand(pattern.substr(i), options); ++ return tail.map(function (t) { ++ return prefix + t; ++ }); ++ } // now we have something like: ++ // {b,c{d,e},{f,g}h}x{y,z} ++ // walk through the set, expanding each part, until ++ // the set ends. then, we'll expand the suffix. ++ // If the set only has a single member, then'll put the {} back ++ // first, handle numeric sets, since they're easier ++ ++ ++ var numset = pattern.match(/^\{(-?[0-9]+)\.\.(-?[0-9]+)\}/); ++ ++ if (numset) { ++ // console.error("numset", numset[1], numset[2]) ++ var suf = braceExpand(pattern.substr(numset[0].length), options), ++ start = +numset[1], ++ end = +numset[2], ++ inc = start > end ? -1 : 1, ++ set = []; ++ ++ for (var i = start; i != end + inc; i += inc) { ++ // append all the suffixes ++ for (var ii = 0, ll = suf.length; ii < ll; ii++) { ++ set.push(i + suf[ii]); ++ } ++ } ++ ++ return set; ++ } // ok, walk through the set ++ // We hope, somewhat optimistically, that there ++ // will be a } at the end. ++ // If the closing brace isn't found, then the pattern is ++ // interpreted as braceExpand("\\" + pattern) so that ++ // the leading \{ will be interpreted literally. ++ ++ ++ var i = 1 // skip the \{ ++ , ++ depth = 1, ++ set = [], ++ member = "", ++ escaping = false; ++ ++ function addMember() { ++ set.push(member); ++ member = ""; ++ } // console.error("Entering for") ++ ++ ++ FOR: for (i = 1, l = pattern.length; i < l; i++) { ++ var c = pattern.charAt(i); // console.error("", i, c) ++ ++ if (escaping) { ++ escaping = false; ++ member += "\\" + c; ++ } else { ++ switch (c) { ++ case "\\": ++ escaping = true; ++ continue; ++ ++ case "{": ++ depth++; ++ member += "{"; ++ continue; ++ ++ case "}": ++ depth--; // if this closes the actual set, then we're done ++ ++ if (depth === 0) { ++ addMember(); // pluck off the close-brace ++ ++ i++; ++ break FOR; ++ } else { ++ member += c; ++ continue; ++ } ++ ++ case ",": ++ if (depth === 1) { ++ addMember(); ++ } else { ++ member += c; ++ } ++ ++ continue; ++ ++ default: ++ member += c; ++ continue; ++ } // switch ++ ++ } // else ++ ++ } // for ++ // now we've either finished the set, and the suffix is ++ // pattern.substr(i), or we have *not* closed the set, ++ // and need to escape the leading brace ++ ++ ++ if (depth !== 0) { ++ // console.error("didn't close", pattern) ++ return braceExpand("\\" + pattern, options); ++ } // x{y,z} -> ["xy", "xz"] ++ // console.error("set", set) ++ // console.error("suffix", pattern.substr(i)) ++ ++ ++ var suf = braceExpand(pattern.substr(i), options); // ["b", "c{d,e}","{f,g}h"] -> ++ // [["b"], ["cd", "ce"], ["fh", "gh"]] ++ ++ var addBraces = set.length === 1; // console.error("set pre-expanded", set) ++ ++ set = set.map(function (p) { ++ return braceExpand(p, options); ++ }); // console.error("set expanded", set) ++ // [["b"], ["cd", "ce"], ["fh", "gh"]] -> ++ // ["b", "cd", "ce", "fh", "gh"] ++ ++ set = set.reduce(function (l, r) { ++ return l.concat(r); ++ }); ++ ++ if (addBraces) { ++ set = set.map(function (s) { ++ return "{" + s + "}"; ++ }); ++ } // now attach the suffixes. ++ ++ ++ var ret = []; ++ ++ for (var i = 0, l = set.length; i < l; i++) { ++ for (var ii = 0, ll = suf.length; ii < ll; ii++) { ++ ret.push(set[i] + suf[ii]); ++ } ++ } ++ ++ return ret; ++ } // 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. ++ ++ ++ Minimatch.prototype.parse = parse; ++ var SUBPARSE = {}; ++ ++ function parse(pattern, isSub) { ++ var options = this.options; // shortcuts ++ ++ if (!options.noglobstar && pattern === "**") return GLOBSTAR; ++ if (pattern === "") return ""; ++ var re = "", ++ hasMagic = !!options.nocase, ++ escaping = false // ? => one single character ++ , ++ patternListStack = [], ++ plType, ++ stateChar, ++ inClass = false, ++ reClassStart = -1, ++ classStart = -1 // . and .. never match anything that doesn't start with ., ++ // even when options.dot is set. ++ , ++ patternStart = pattern.charAt(0) === "." ? "" // anything ++ // not (start or / followed by . or .. followed by / or end) ++ : options.dot ? "(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))" : "(?!\\.)"; ++ ++ function 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; ++ } ++ ++ stateChar = false; ++ } ++ } ++ ++ for (var i = 0, len = pattern.length, c; i < len && (c = pattern.charAt(i)); i++) { ++ if (options.debug) { ++ console.error("%s\t%s %s %j", pattern, i, re, c); ++ } // skip over any that are escaped. ++ ++ ++ if (escaping && reSpecials[c]) { ++ re += "\\" + c; ++ escaping = false; ++ continue; ++ } ++ ++ switch (c) { ++ case "/": ++ // completely not allowed, even escaped. ++ // Should already be path-split by now. ++ return false; ++ ++ case "\\": ++ clearStateChar(); ++ escaping = true; ++ continue; ++ // the various stateChar values ++ // for the "extglob" stuff. ++ ++ case "?": ++ case "*": ++ case "+": ++ case "@": ++ case "!": ++ if (options.debug) { ++ console.error("%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) { ++ if (c === "!" && i === classStart + 1) c = "^"; ++ re += c; ++ 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. ++ ++ ++ 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; ++ } ++ ++ plType = stateChar; ++ patternListStack.push({ ++ type: plType, ++ start: i - 1, ++ reStart: re.length ++ }); // negation is (?:(?!js)[^/]*) ++ ++ re += stateChar === "!" ? "(?:(?!" : "(?:"; ++ stateChar = false; ++ continue; ++ ++ case ")": ++ if (inClass || !patternListStack.length) { ++ re += "\\)"; ++ continue; ++ } ++ ++ hasMagic = true; ++ re += ")"; ++ plType = patternListStack.pop().type; // negation is (?:(?!js)[^/]*) ++ // The others are (?:) ++ ++ switch (plType) { ++ case "!": ++ re += "[^/]*?)"; ++ break; ++ ++ case "?": ++ case "+": ++ case "*": ++ re += plType; ++ // the default anyway ++ } ++ ++ continue; ++ ++ case "|": ++ if (inClass || !patternListStack.length || escaping) { ++ re += "\\|"; ++ escaping = false; ++ continue; ++ } ++ ++ re += "|"; ++ 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; ++ escaping = false; ++ continue; ++ } // finish up the class. ++ ++ ++ hasMagic = true; ++ inClass = false; ++ re += c; ++ continue; ++ ++ default: ++ // swallow any state char that wasn't consumed ++ clearStateChar(); ++ ++ if (escaping) { ++ // no need ++ escaping = false; ++ } else if (reSpecials[c] && !(c === "^" && inClass)) { ++ re += "\\"; ++ } ++ ++ re += c; ++ } // 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 ++ var cs = pattern.substr(classStart + 1), ++ sp = this.parse(cs, SUBPARSE); ++ re = re.substr(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. ++ ++ ++ var pl; ++ ++ while (pl = patternListStack.pop()) { ++ var tail = re.slice(pl.reStart + 3); // maybe some even number of \, then maybe 1 \, followed by a | ++ ++ tail = tail.replace(/((?:\\{2})*)(\\?)\|/g, function (_, $1, $2) { ++ 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 + "|"; ++ }); // console.error("tail=%j\n %s", tail, tail) ++ ++ var 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 ++ ++ ++ var addPatternStart = false; ++ ++ switch (re.charAt(0)) { ++ case ".": ++ case "[": ++ case "(": ++ addPatternStart = true; ++ } // 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]; ++ } // 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); ++ } ++ ++ var flags = options.nocase ? "i" : "", ++ regExp = new RegExp("^" + re + "$", flags); ++ regExp._glob = pattern; ++ regExp._src = re; ++ return regExp; ++ } ++ ++ minimatch.makeRe = function (pattern, options) { ++ return new Minimatch(pattern, options || {}).makeRe(); ++ }; ++ ++ Minimatch.prototype.makeRe = makeRe; ++ ++ function 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. ++ ++ var set = this.set; ++ if (!set.length) return this.regexp = false; ++ var options = this.options; ++ var twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot, ++ flags = options.nocase ? "i" : ""; ++ var re = set.map(function (pattern) { ++ return pattern.map(function (p) { ++ return p === GLOBSTAR ? twoStar : typeof p === "string" ? regExpEscape(p) : p._src; ++ }).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 { ++ return this.regexp = new RegExp(re, flags); ++ } catch (ex) { ++ return this.regexp = false; ++ } ++ } ++ ++ minimatch.match = function (list, pattern, options) { ++ var mm = new Minimatch(pattern, options); ++ list = list.filter(function (f) { ++ return mm.match(f); ++ }); ++ ++ if (options.nonull && !list.length) { ++ list.push(pattern); ++ } ++ ++ return list; ++ }; ++ ++ Minimatch.prototype.match = match; ++ ++ function match(f, partial) { ++ // console.error("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; ++ var options = this.options; // windows: need to use /, not \ ++ // On other platforms, \ is a valid (albeit bad) filename char. ++ ++ if (platform === "win32") { ++ f = f.split("\\").join("/"); ++ } // treat the test path as a set of pathparts. ++ ++ ++ f = f.split(slashSplit); ++ ++ if (options.debug) { ++ console.error(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. ++ ++ ++ var set = this.set; // console.error(this.pattern, "set", set) ++ ++ for (var i = 0, l = set.length; i < l; i++) { ++ var pattern = set[i]; ++ var hit = this.matchOne(f, 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; ++ } // 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. ++ ++ ++ Minimatch.prototype.matchOne = function (file, pattern, partial) { ++ var options = this.options; ++ ++ if (options.debug) { ++ console.error("matchOne", { ++ "this": this, ++ file: file, ++ pattern: pattern ++ }); ++ } ++ ++ if (options.matchBase && pattern.length === 1) { ++ file = path$1.basename(file.join("/")).split("/"); ++ } ++ ++ if (options.debug) { ++ console.error("matchOne", file.length, pattern.length); ++ } ++ ++ for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) { ++ if (options.debug) { ++ console.error("matchOne loop"); ++ } ++ ++ var p = pattern[pi], ++ f = file[fi]; ++ ++ if (options.debug) { ++ console.error(pattern, p, f); ++ } // should be impossible. ++ // some invalid regexp stuff in the set. ++ ++ ++ if (p === false) return false; ++ ++ if (p === GLOBSTAR) { ++ if (options.debug) console.error('GLOBSTAR', [pattern, p, f]); // "**" ++ // a/**/b/**/c would match the following: ++ // a/b/x/y/z/c ++ // a/x/y/z/b/c ++ // a/b/x/b/x/c ++ // a/b/c ++ // To do this, take the rest of the pattern after ++ // the **, and see if it would match the file remainder. ++ // If so, return success. ++ // If not, the ** "swallows" a segment, and try again. ++ // This is recursively awful. ++ // ++ // a/**/b/**/c matching a/b/x/y/z/c ++ // - a matches a ++ // - doublestar ++ // - matchOne(b/x/y/z/c, b/**/c) ++ // - b matches b ++ // - doublestar ++ // - matchOne(x/y/z/c, c) -> no ++ // - matchOne(y/z/c, c) -> no ++ // - matchOne(z/c, c) -> no ++ // - matchOne(c, c) yes, hit ++ ++ var fr = fi, ++ pr = pi + 1; ++ ++ if (pr === pl) { ++ if (options.debug) console.error('** at the end'); // a ** at the end will just swallow the rest. ++ // We have found a match. ++ // however, it will not swallow /.x, unless ++ // options.dot is set. ++ // . and .. are *never* matched by **, for explosively ++ // exponential reasons. ++ ++ for (; fi < fl; fi++) { ++ if (file[fi] === "." || file[fi] === ".." || !options.dot && file[fi].charAt(0) === ".") return false; ++ } ++ ++ return true; ++ } // ok, let's see if we can swallow whatever we can. ++ ++ ++ WHILE: while (fr < fl) { ++ var swallowee = file[fr]; ++ ++ if (options.debug) { ++ console.error('\nglobstar while', file, fr, pattern, pr, swallowee); ++ } // XXX remove this slice. Just pass the start index. ++ ++ ++ if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) { ++ if (options.debug) console.error('globstar found match!', fr, fl, swallowee); // found a match. ++ ++ return true; ++ } else { ++ // can't swallow "." or ".." ever. ++ // can only swallow ".foo" when explicitly asked. ++ if (swallowee === "." || swallowee === ".." || !options.dot && swallowee.charAt(0) === ".") { ++ if (options.debug) console.error("dot detected!", file, fr, pattern, pr); ++ break WHILE; ++ } // ** swallows a segment, and continue. ++ ++ ++ if (options.debug) console.error('globstar swallow a segment, and continue'); ++ fr++; ++ } ++ } // no match was found. ++ // However, in partial mode, we can't say this is necessarily over. ++ // If there's more *pattern* left, then ++ ++ ++ if (partial) { ++ // ran out of file ++ // console.error("\n>>> no match, partial?", file, fr, pattern, pr) ++ if (fr === fl) return true; ++ } ++ ++ return false; ++ } // something other than ** ++ // non-magic patterns just have to match exactly ++ // patterns with magic have been turned into regexps. ++ ++ ++ var hit; ++ ++ if (typeof p === "string") { ++ if (options.nocase) { ++ hit = f.toLowerCase() === p.toLowerCase(); ++ } else { ++ hit = f === p; ++ } ++ ++ if (options.debug) { ++ console.error("string match", p, f, hit); ++ } ++ } else { ++ hit = f.match(p); ++ ++ if (options.debug) { ++ console.error("pattern match", p, f, hit); ++ } ++ } ++ ++ if (!hit) return false; ++ } // Note: ending in / means that we'll get a final "" ++ // at the end of the pattern. This can only match a ++ // corresponding "" at the end of the file. ++ // If the file ends in /, then it can only match a ++ // a pattern that ends in /, unless the pattern just ++ // doesn't have any more for it. But, a/b/ should *not* ++ // match "a/b/*", even though "" matches against the ++ // [^/]*? pattern, except in partial mode, where it might ++ // simply not be reached yet. ++ // However, a/b/ should still satisfy a/* ++ // 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 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/ ++ var emptyFileEnd = fi === fl - 1 && file[fi] === ""; ++ return emptyFileEnd; ++ } // should be unreachable. ++ ++ ++ throw new Error("wtf?"); ++ }; // replace stuff like \* with * ++ ++ ++ function globUnescape(s) { ++ return s.replace(/\\(.)/g, "$1"); ++ } ++ ++ function regExpEscape(s) { ++ return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"); ++ } ++}); ++var fnmatch_1 = fnmatch.minimatch; ++ ++var ini = createCommonjsModule(function (module, exports) { ++ ++ var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) { ++ return new (P || (P = Promise))(function (resolve, reject) { ++ function fulfilled(value) { ++ try { ++ step(generator.next(value)); ++ } catch (e) { ++ reject(e); ++ } ++ } ++ ++ function rejected(value) { ++ try { ++ step(generator["throw"](value)); ++ } catch (e) { ++ reject(e); ++ } ++ } ++ ++ function step(result) { ++ result.done ? resolve(result.value) : new P(function (resolve) { ++ resolve(result.value); ++ }).then(fulfilled, rejected); ++ } ++ ++ step((generator = generator.apply(thisArg, _arguments || [])).next()); ++ }); ++ }; ++ ++ var __generator = this && this.__generator || function (thisArg, body) { ++ var _ = { ++ label: 0, ++ sent: function () { ++ if (t[0] & 1) throw t[1]; ++ return t[1]; ++ }, ++ trys: [], ++ ops: [] ++ }, ++ f, ++ y, ++ t, ++ g; ++ return g = { ++ next: verb(0), ++ "throw": verb(1), ++ "return": verb(2) ++ }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { ++ return this; ++ }), g; ++ ++ function verb(n) { ++ return function (v) { ++ return step([n, v]); ++ }; ++ } ++ ++ function step(op) { ++ if (f) throw new TypeError("Generator is already executing."); ++ ++ while (_) try { ++ if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; ++ if (y = 0, t) op = [op[0] & 2, t.value]; ++ ++ switch (op[0]) { ++ case 0: ++ case 1: ++ t = op; ++ break; ++ ++ case 4: ++ _.label++; ++ return { ++ value: op[1], ++ done: false ++ }; ++ ++ case 5: ++ _.label++; ++ y = op[1]; ++ op = [0]; ++ continue; ++ ++ case 7: ++ op = _.ops.pop(); ++ ++ _.trys.pop(); ++ ++ continue; ++ ++ default: ++ if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { ++ _ = 0; ++ continue; ++ } ++ ++ if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) { ++ _.label = op[1]; ++ break; ++ } ++ ++ if (op[0] === 6 && _.label < t[1]) { ++ _.label = t[1]; ++ t = op; ++ break; ++ } ++ ++ if (t && _.label < t[2]) { ++ _.label = t[2]; ++ ++ _.ops.push(op); ++ ++ break; ++ } ++ ++ if (t[2]) _.ops.pop(); ++ ++ _.trys.pop(); ++ ++ continue; ++ } ++ ++ op = body.call(thisArg, _); ++ } catch (e) { ++ op = [6, e]; ++ y = 0; ++ } finally { ++ f = t = 0; ++ } ++ ++ if (op[0] & 5) throw op[1]; ++ return { ++ value: op[0] ? op[1] : void 0, ++ done: true ++ }; ++ } ++ }; ++ ++ var __importStar = this && this.__importStar || function (mod) { ++ if (mod && mod.__esModule) return mod; ++ var result = {}; ++ if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; ++ result["default"] = mod; ++ return result; ++ }; ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ var fs = __importStar(fs$2); ++ /** ++ * define the possible values: ++ * section: [section] ++ * param: key=value ++ * comment: ;this is a comment ++ */ ++ ++ ++ var regex = { ++ section: /^\s*\[(([^#;]|\\#|\\;)+)\]\s*([#;].*)?$/, ++ param: /^\s*([\w\.\-\_]+)\s*[=:]\s*(.*?)\s*([#;].*)?$/, ++ comment: /^\s*[#;].*$/ ++ }; ++ /** ++ * Parses an .ini file ++ * @param file The location of the .ini file ++ */ ++ ++ function parse(file) { ++ return __awaiter(this, void 0, void 0, function () { ++ return __generator(this, function (_a) { ++ return [2 ++ /*return*/ ++ , new Promise(function (resolve, reject) { ++ fs.readFile(file, 'utf8', function (err, data) { ++ if (err) { ++ reject(err); ++ return; ++ } ++ ++ resolve(parseString(data)); ++ }); ++ })]; ++ }); ++ }); ++ } ++ ++ exports.parse = parse; ++ ++ function parseSync(file) { ++ return parseString(fs.readFileSync(file, 'utf8')); ++ } ++ ++ exports.parseSync = parseSync; ++ ++ function parseString(data) { ++ var sectionBody = {}; ++ var sectionName = null; ++ var value = [[sectionName, sectionBody]]; ++ var lines = data.split(/\r\n|\r|\n/); ++ lines.forEach(function (line) { ++ var match; ++ ++ if (regex.comment.test(line)) { ++ return; ++ } ++ ++ if (regex.param.test(line)) { ++ match = line.match(regex.param); ++ sectionBody[match[1]] = match[2]; ++ } else if (regex.section.test(line)) { ++ match = line.match(regex.section); ++ sectionName = match[1]; ++ sectionBody = {}; ++ value.push([sectionName, sectionBody]); ++ } ++ }); ++ return value; ++ } ++ ++ exports.parseString = parseString; ++}); ++unwrapExports(ini); ++var ini_1 = ini.parse; ++var ini_2 = ini.parseSync; ++var ini_3 = ini.parseString; ++ ++var name$1 = "editorconfig"; ++var version$1 = "0.15.3"; ++var description$1 = "EditorConfig File Locator and Interpreter for Node.js"; ++var keywords = [ ++ "editorconfig", ++ "core" ++]; ++var main$1 = "src/index.js"; ++var contributors = [ ++ "Hong Xu (topbug.net)", ++ "Jed Mao (https://github.com/jedmao/)", ++ "Trey Hunner (http://treyhunner.com)" ++]; ++var directories = { ++ bin: "./bin", ++ lib: "./lib" ++}; ++var scripts$1 = { ++ clean: "rimraf dist", ++ prebuild: "npm run clean", ++ build: "tsc", ++ pretest: "npm run lint && npm run build && npm run copy && cmake .", ++ test: "ctest .", ++ "pretest:ci": "npm run pretest", ++ "test:ci": "ctest -VV --output-on-failure .", ++ lint: "npm run eclint && npm run tslint", ++ eclint: "eclint check --indent_size ignore \"src/**\"", ++ tslint: "tslint --project tsconfig.json --exclude package.json", ++ copy: "cpy .npmignore LICENSE README.md CHANGELOG.md dist && cpy bin/* dist/bin && cpy src/lib/fnmatch*.* dist/src/lib", ++ prepub: "npm run lint && npm run build && npm run copy", ++ pub: "npm publish ./dist" ++}; ++var repository$1 = { ++ type: "git", ++ url: "git://github.com/editorconfig/editorconfig-core-js.git" ++}; ++var bugs = "https://github.com/editorconfig/editorconfig-core-js/issues"; ++var author$1 = "EditorConfig Team"; ++var license$1 = "MIT"; ++var dependencies$1 = { ++ commander: "^2.19.0", ++ "lru-cache": "^4.1.5", ++ semver: "^5.6.0", ++ sigmund: "^1.0.1" ++}; ++var devDependencies$1 = { ++ "@types/mocha": "^5.2.6", ++ "@types/node": "^10.12.29", ++ "@types/semver": "^5.5.0", ++ "cpy-cli": "^2.0.0", ++ eclint: "^2.8.1", ++ mocha: "^5.2.0", ++ rimraf: "^2.6.3", ++ should: "^13.2.3", ++ tslint: "^5.13.1", ++ typescript: "^3.3.3333" ++}; ++var _package$2 = { ++ name: name$1, ++ version: version$1, ++ description: description$1, ++ keywords: keywords, ++ main: main$1, ++ contributors: contributors, ++ directories: directories, ++ scripts: scripts$1, ++ repository: repository$1, ++ bugs: bugs, ++ author: author$1, ++ license: license$1, ++ dependencies: dependencies$1, ++ devDependencies: devDependencies$1 ++}; ++ ++var _package$3 = /*#__PURE__*/Object.freeze({ ++ __proto__: null, ++ name: name$1, ++ version: version$1, ++ description: description$1, ++ keywords: keywords, ++ main: main$1, ++ contributors: contributors, ++ directories: directories, ++ scripts: scripts$1, ++ repository: repository$1, ++ bugs: bugs, ++ author: author$1, ++ license: license$1, ++ dependencies: dependencies$1, ++ devDependencies: devDependencies$1, ++ 'default': _package$2 ++}); ++ ++var require$$4 = getCjsExportFromNamespace(_package$3); ++ ++var src = createCommonjsModule(function (module, exports) { ++ ++ var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) { ++ return new (P || (P = Promise))(function (resolve, reject) { ++ function fulfilled(value) { ++ try { ++ step(generator.next(value)); ++ } catch (e) { ++ reject(e); ++ } ++ } ++ ++ function rejected(value) { ++ try { ++ step(generator["throw"](value)); ++ } catch (e) { ++ reject(e); ++ } ++ } ++ ++ function step(result) { ++ result.done ? resolve(result.value) : new P(function (resolve) { ++ resolve(result.value); ++ }).then(fulfilled, rejected); ++ } ++ ++ step((generator = generator.apply(thisArg, _arguments || [])).next()); ++ }); ++ }; ++ ++ var __generator = this && this.__generator || function (thisArg, body) { ++ var _ = { ++ label: 0, ++ sent: function () { ++ if (t[0] & 1) throw t[1]; ++ return t[1]; ++ }, ++ trys: [], ++ ops: [] ++ }, ++ f, ++ y, ++ t, ++ g; ++ return g = { ++ next: verb(0), ++ "throw": verb(1), ++ "return": verb(2) ++ }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { ++ return this; ++ }), g; ++ ++ function verb(n) { ++ return function (v) { ++ return step([n, v]); ++ }; ++ } ++ ++ function step(op) { ++ if (f) throw new TypeError("Generator is already executing."); ++ ++ while (_) try { ++ if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; ++ if (y = 0, t) op = [op[0] & 2, t.value]; ++ ++ switch (op[0]) { ++ case 0: ++ case 1: ++ t = op; ++ break; ++ ++ case 4: ++ _.label++; ++ return { ++ value: op[1], ++ done: false ++ }; ++ ++ case 5: ++ _.label++; ++ y = op[1]; ++ op = [0]; ++ continue; ++ ++ case 7: ++ op = _.ops.pop(); ++ ++ _.trys.pop(); ++ ++ continue; ++ ++ default: ++ if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { ++ _ = 0; ++ continue; ++ } ++ ++ if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) { ++ _.label = op[1]; ++ break; ++ } ++ ++ if (op[0] === 6 && _.label < t[1]) { ++ _.label = t[1]; ++ t = op; ++ break; ++ } ++ ++ if (t && _.label < t[2]) { ++ _.label = t[2]; ++ ++ _.ops.push(op); ++ ++ break; ++ } ++ ++ if (t[2]) _.ops.pop(); ++ ++ _.trys.pop(); ++ ++ continue; ++ } ++ ++ op = body.call(thisArg, _); ++ } catch (e) { ++ op = [6, e]; ++ y = 0; ++ } finally { ++ f = t = 0; ++ } ++ ++ if (op[0] & 5) throw op[1]; ++ return { ++ value: op[0] ? op[1] : void 0, ++ done: true ++ }; ++ } ++ }; ++ ++ var __importStar = this && this.__importStar || function (mod) { ++ if (mod && mod.__esModule) return mod; ++ var result = {}; ++ if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; ++ result["default"] = mod; ++ return result; ++ }; ++ ++ var __importDefault = this && this.__importDefault || function (mod) { ++ return mod && mod.__esModule ? mod : { ++ "default": mod ++ }; ++ }; ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ var fs = __importStar(fs$2); ++ ++ var path = __importStar(path$1); ++ ++ var semver = __importStar(semver$2); ++ ++ var fnmatch_1 = __importDefault(fnmatch); ++ ++ exports.parseString = ini.parseString; ++ ++ var package_json_1 = __importDefault(require$$4); ++ ++ var knownProps = { ++ end_of_line: true, ++ indent_style: true, ++ indent_size: true, ++ insert_final_newline: true, ++ trim_trailing_whitespace: true, ++ charset: true ++ }; ++ ++ function fnmatch$1(filepath, glob) { ++ var matchOptions = { ++ matchBase: true, ++ dot: true, ++ noext: true ++ }; ++ glob = glob.replace(/\*\*/g, '{*,**/**/**}'); ++ return fnmatch_1.default(filepath, glob, matchOptions); ++ } ++ ++ function getConfigFileNames(filepath, options) { ++ var paths = []; ++ ++ do { ++ filepath = path.dirname(filepath); ++ paths.push(path.join(filepath, options.config)); ++ } while (filepath !== options.root); ++ ++ return paths; ++ } ++ ++ function processMatches(matches, version) { ++ // Set indent_size to 'tab' if indent_size is unspecified and ++ // indent_style is set to 'tab'. ++ if ('indent_style' in matches && matches.indent_style === 'tab' && !('indent_size' in matches) && semver.gte(version, '0.10.0')) { ++ matches.indent_size = 'tab'; ++ } // Set tab_width to indent_size if indent_size is specified and ++ // tab_width is unspecified ++ ++ ++ if ('indent_size' in matches && !('tab_width' in matches) && matches.indent_size !== 'tab') { ++ matches.tab_width = matches.indent_size; ++ } // Set indent_size to tab_width if indent_size is 'tab' ++ ++ ++ if ('indent_size' in matches && 'tab_width' in matches && matches.indent_size === 'tab') { ++ matches.indent_size = matches.tab_width; ++ } ++ ++ return matches; ++ } ++ ++ function processOptions(options, filepath) { ++ if (options === void 0) { ++ options = {}; ++ } ++ ++ return { ++ config: options.config || '.editorconfig', ++ version: options.version || package_json_1.default.version, ++ root: path.resolve(options.root || path.parse(filepath).root) ++ }; ++ } ++ ++ function buildFullGlob(pathPrefix, glob) { ++ switch (glob.indexOf('/')) { ++ case -1: ++ glob = '**/' + glob; ++ break; ++ ++ case 0: ++ glob = glob.substring(1); ++ break; ++ } ++ ++ return path.join(pathPrefix, glob); ++ } ++ ++ function extendProps(props, options) { ++ if (props === void 0) { ++ props = {}; ++ } ++ ++ if (options === void 0) { ++ options = {}; ++ } ++ ++ for (var key in options) { ++ if (options.hasOwnProperty(key)) { ++ var value = options[key]; ++ var key2 = key.toLowerCase(); ++ var value2 = value; ++ ++ if (knownProps[key2]) { ++ value2 = value.toLowerCase(); ++ } ++ ++ try { ++ value2 = JSON.parse(value); ++ } catch (e) {} ++ ++ if (typeof value === 'undefined' || value === null) { ++ // null and undefined are values specific to JSON (no special meaning ++ // in editorconfig) & should just be returned as regular strings. ++ value2 = String(value); ++ } ++ ++ props[key2] = value2; ++ } ++ } ++ ++ return props; ++ } ++ ++ function parseFromConfigs(configs, filepath, options) { ++ return processMatches(configs.reverse().reduce(function (matches, file) { ++ var pathPrefix = path.dirname(file.name); ++ file.contents.forEach(function (section) { ++ var glob = section[0]; ++ var options2 = section[1]; ++ ++ if (!glob) { ++ return; ++ } ++ ++ var fullGlob = buildFullGlob(pathPrefix, glob); ++ ++ if (!fnmatch$1(filepath, fullGlob)) { ++ return; ++ } ++ ++ matches = extendProps(matches, options2); ++ }); ++ return matches; ++ }, {}), options.version); ++ } ++ ++ function getConfigsForFiles(files) { ++ var configs = []; ++ ++ for (var i in files) { ++ if (files.hasOwnProperty(i)) { ++ var file = files[i]; ++ var contents = ini.parseString(file.contents); ++ configs.push({ ++ name: file.name, ++ contents: contents ++ }); ++ ++ if ((contents[0][1].root || '').toLowerCase() === 'true') { ++ break; ++ } ++ } ++ } ++ ++ return configs; ++ } ++ ++ function readConfigFiles(filepaths) { ++ return __awaiter(this, void 0, void 0, function () { ++ return __generator(this, function (_a) { ++ return [2 ++ /*return*/ ++ , Promise.all(filepaths.map(function (name) { ++ return new Promise(function (resolve) { ++ fs.readFile(name, 'utf8', function (err, data) { ++ resolve({ ++ name: name, ++ contents: err ? '' : data ++ }); ++ }); ++ }); ++ }))]; ++ }); ++ }); ++ } ++ ++ function readConfigFilesSync(filepaths) { ++ var files = []; ++ var file; ++ filepaths.forEach(function (filepath) { ++ try { ++ file = fs.readFileSync(filepath, 'utf8'); ++ } catch (e) { ++ file = ''; ++ } ++ ++ files.push({ ++ name: filepath, ++ contents: file ++ }); ++ }); ++ return files; ++ } ++ ++ function opts(filepath, options) { ++ if (options === void 0) { ++ options = {}; ++ } ++ ++ var resolvedFilePath = path.resolve(filepath); ++ return [resolvedFilePath, processOptions(options, resolvedFilePath)]; ++ } ++ ++ function parseFromFiles(filepath, files, options) { ++ if (options === void 0) { ++ options = {}; ++ } ++ ++ return __awaiter(this, void 0, void 0, function () { ++ var _a, resolvedFilePath, processedOptions; ++ ++ return __generator(this, function (_b) { ++ _a = opts(filepath, options), resolvedFilePath = _a[0], processedOptions = _a[1]; ++ return [2 ++ /*return*/ ++ , files.then(getConfigsForFiles).then(function (configs) { ++ return parseFromConfigs(configs, resolvedFilePath, processedOptions); ++ })]; ++ }); ++ }); ++ } ++ ++ exports.parseFromFiles = parseFromFiles; ++ ++ function parseFromFilesSync(filepath, files, options) { ++ if (options === void 0) { ++ options = {}; ++ } ++ ++ var _a = opts(filepath, options), ++ resolvedFilePath = _a[0], ++ processedOptions = _a[1]; ++ ++ return parseFromConfigs(getConfigsForFiles(files), resolvedFilePath, processedOptions); ++ } ++ ++ exports.parseFromFilesSync = parseFromFilesSync; ++ ++ function parse(_filepath, _options) { ++ if (_options === void 0) { ++ _options = {}; ++ } ++ ++ return __awaiter(this, void 0, void 0, function () { ++ var _a, resolvedFilePath, processedOptions, filepaths; ++ ++ return __generator(this, function (_b) { ++ _a = opts(_filepath, _options), resolvedFilePath = _a[0], processedOptions = _a[1]; ++ filepaths = getConfigFileNames(resolvedFilePath, processedOptions); ++ return [2 ++ /*return*/ ++ , readConfigFiles(filepaths).then(getConfigsForFiles).then(function (configs) { ++ return parseFromConfigs(configs, resolvedFilePath, processedOptions); ++ })]; ++ }); ++ }); ++ } ++ ++ exports.parse = parse; ++ ++ function parseSync(_filepath, _options) { ++ if (_options === void 0) { ++ _options = {}; ++ } ++ ++ var _a = opts(_filepath, _options), ++ resolvedFilePath = _a[0], ++ processedOptions = _a[1]; ++ ++ var filepaths = getConfigFileNames(resolvedFilePath, processedOptions); ++ var files = readConfigFilesSync(filepaths); ++ return parseFromConfigs(getConfigsForFiles(files), resolvedFilePath, processedOptions); ++ } ++ ++ exports.parseSync = parseSync; ++}); ++unwrapExports(src); ++var src_1 = src.parseString; ++var src_2 = src.parseFromFiles; ++var src_3 = src.parseFromFilesSync; ++var src_4 = src.parse; ++var src_5 = src.parseSync; ++ ++var editorconfigToPrettier = editorConfigToPrettier; ++ ++function removeUnset(editorConfig) { ++ const result = {}; ++ const keys = Object.keys(editorConfig); ++ ++ for (let i = 0; i < keys.length; i++) { ++ const key = keys[i]; ++ ++ if (editorConfig[key] === "unset") { ++ continue; ++ } ++ ++ result[key] = editorConfig[key]; ++ } ++ ++ return result; ++} ++ ++function editorConfigToPrettier(editorConfig) { ++ if (!editorConfig) { ++ return null; ++ } ++ ++ editorConfig = removeUnset(editorConfig); ++ ++ if (Object.keys(editorConfig).length === 0) { ++ return null; ++ } ++ ++ const result = {}; ++ ++ if (editorConfig.indent_style) { ++ result.useTabs = editorConfig.indent_style === "tab"; ++ } ++ ++ if (editorConfig.indent_size === "tab") { ++ result.useTabs = true; ++ } ++ ++ if (result.useTabs && editorConfig.tab_width) { ++ result.tabWidth = editorConfig.tab_width; ++ } else if (editorConfig.indent_style === "space" && editorConfig.indent_size && editorConfig.indent_size !== "tab") { ++ result.tabWidth = editorConfig.indent_size; ++ } else if (editorConfig.tab_width !== undefined) { ++ result.tabWidth = editorConfig.tab_width; ++ } ++ ++ if (editorConfig.max_line_length && editorConfig.max_line_length !== "off") { ++ result.printWidth = editorConfig.max_line_length; ++ } ++ ++ if (editorConfig.quote_type === "single") { ++ result.singleQuote = true; ++ } else if (editorConfig.quote_type === "double") { ++ result.singleQuote = false; ++ } ++ ++ if (["cr", "crlf", "lf"].indexOf(editorConfig.end_of_line) !== -1) { ++ result.endOfLine = editorConfig.end_of_line; ++ } ++ ++ return result; ++} ++ ++function markerExists(files, markers) { ++ return markers.some(function (marker) { ++ return files.some(function (file) { ++ return file === marker; ++ }); ++ }); ++} ++ ++function traverseFolder(directory, levels, markers) { ++ var files = fs$2.readdirSync(directory); ++ ++ if (levels === 0) { ++ return null; ++ } else if (markerExists(files, markers)) { ++ return directory; ++ } else { ++ return traverseFolder(path$1.resolve(directory, '..'), levels - 1, markers); ++ } ++} ++ ++var findProjectRoot = function findRoot(dir, opts) { ++ if (!dir) throw new Error("Directory not defined"); ++ opts = opts || {}; ++ var levels = opts.maxDepth || findRoot.MAX_DEPTH; ++ var markers = opts.markers || findRoot.MARKERS; ++ return traverseFolder(dir, levels, markers); ++}; ++ ++var MAX_DEPTH = 9; ++var MARKERS = ['.git', '.hg']; ++findProjectRoot.MAX_DEPTH = MAX_DEPTH; ++findProjectRoot.MARKERS = MARKERS; ++ ++const jsonStringifyMem = fn => mem_1(fn, { ++ cacheKey: JSON.stringify ++}); ++ ++const maybeParse = (filePath, parse) => { ++ // findProjectRoot will throw an error if we pass a nonexistent directory to ++ // it, which is possible, for example, when the path is given via ++ // --stdin-filepath. So, first, traverse up until we find an existing ++ // directory. ++ let dirPath = path$1.dirname(path$1.resolve(filePath)); ++ const fsRoot = path$1.parse(dirPath).root; ++ ++ while (dirPath !== fsRoot && !fs$2.existsSync(dirPath)) { ++ dirPath = path$1.dirname(dirPath); ++ } ++ ++ const root = findProjectRoot(dirPath); ++ return filePath && parse(filePath, { ++ root ++ }); ++}; ++ ++const editorconfigAsyncNoCache = async filePath => { ++ const editorConfig = await maybeParse(filePath, src.parse); ++ return editorconfigToPrettier(editorConfig); ++}; ++ ++const editorconfigAsyncWithCache = jsonStringifyMem(editorconfigAsyncNoCache); ++ ++const editorconfigSyncNoCache = filePath => { ++ return editorconfigToPrettier(maybeParse(filePath, src.parseSync)); ++}; ++ ++const editorconfigSyncWithCache = jsonStringifyMem(editorconfigSyncNoCache); ++ ++function getLoadFunction(opts) { ++ if (!opts.editorconfig) { ++ return () => null; ++ } ++ ++ if (opts.sync) { ++ return opts.cache ? editorconfigSyncWithCache : editorconfigSyncNoCache; ++ } ++ ++ return opts.cache ? editorconfigAsyncWithCache : editorconfigAsyncNoCache; ++} ++ ++function clearCache() { ++ mem_1.clear(editorconfigSyncWithCache); ++ mem_1.clear(editorconfigAsyncWithCache); ++} ++ ++var resolveConfigEditorconfig = { ++ getLoadFunction, ++ clearCache ++}; ++ ++const ParserEND = 0x110000; ++ ++class ParserError extends Error { ++ /* istanbul ignore next */ ++ constructor(msg, filename, linenumber) { ++ super('[ParserError] ' + msg, filename, linenumber); ++ this.name = 'ParserError'; ++ this.code = 'ParserError'; ++ if (Error.captureStackTrace) Error.captureStackTrace(this, ParserError); ++ } ++ ++} ++ ++class State { ++ constructor(parser) { ++ this.parser = parser; ++ this.buf = ''; ++ this.returned = null; ++ this.result = null; ++ this.resultTable = null; ++ this.resultArr = null; ++ } ++ ++} ++ ++class Parser { ++ constructor() { ++ this.pos = 0; ++ this.col = 0; ++ this.line = 0; ++ this.obj = {}; ++ this.ctx = this.obj; ++ this.stack = []; ++ this._buf = ''; ++ this.char = null; ++ this.ii = 0; ++ this.state = new State(this.parseStart); ++ } ++ ++ parse(str) { ++ /* istanbul ignore next */ ++ if (str.length === 0 || str.length == null) return; ++ this._buf = String(str); ++ this.ii = -1; ++ this.char = -1; ++ let getNext; ++ ++ while (getNext === false || this.nextChar()) { ++ getNext = this.runOne(); ++ } ++ ++ this._buf = null; ++ } ++ ++ nextChar() { ++ if (this.char === 0x0A) { ++ ++this.line; ++ this.col = -1; ++ } ++ ++ ++this.ii; ++ this.char = this._buf.codePointAt(this.ii); ++ ++this.pos; ++ ++this.col; ++ return this.haveBuffer(); ++ } ++ ++ haveBuffer() { ++ return this.ii < this._buf.length; ++ } ++ ++ runOne() { ++ return this.state.parser.call(this, this.state.returned); ++ } ++ ++ finish() { ++ this.char = ParserEND; ++ let last; ++ ++ do { ++ last = this.state.parser; ++ this.runOne(); ++ } while (this.state.parser !== last); ++ ++ this.ctx = null; ++ this.state = null; ++ this._buf = null; ++ return this.obj; ++ } ++ ++ next(fn) { ++ /* istanbul ignore next */ ++ if (typeof fn !== 'function') throw new ParserError('Tried to set state to non-existent state: ' + JSON.stringify(fn)); ++ this.state.parser = fn; ++ } ++ ++ goto(fn) { ++ this.next(fn); ++ return this.runOne(); ++ } ++ ++ call(fn, returnWith) { ++ if (returnWith) this.next(returnWith); ++ this.stack.push(this.state); ++ this.state = new State(fn); ++ } ++ ++ callNow(fn, returnWith) { ++ this.call(fn, returnWith); ++ return this.runOne(); ++ } ++ ++ return(value) { ++ /* istanbul ignore next */ ++ if (this.stack.length === 0) throw this.error(new ParserError('Stack underflow')); ++ if (value === undefined) value = this.state.buf; ++ this.state = this.stack.pop(); ++ this.state.returned = value; ++ } ++ ++ returnNow(value) { ++ this.return(value); ++ return this.runOne(); ++ } ++ ++ consume() { ++ /* istanbul ignore next */ ++ if (this.char === ParserEND) throw this.error(new ParserError('Unexpected end-of-buffer')); ++ this.state.buf += this._buf[this.ii]; ++ } ++ ++ error(err) { ++ err.line = this.line; ++ err.col = this.col; ++ err.pos = this.pos; ++ return err; ++ } ++ /* istanbul ignore next */ ++ ++ ++ parseStart() { ++ throw new ParserError('Must declare a parseStart method'); ++ } ++ ++} ++ ++Parser.END = ParserEND; ++Parser.Error = ParserError; ++var parser$1 = Parser; ++ ++var createDatetime = value => { ++ const date = new Date(value); ++ /* istanbul ignore if */ ++ ++ if (isNaN(date)) { ++ throw new TypeError('Invalid Datetime'); ++ } else { ++ return date; ++ } ++}; ++ ++var formatNum = (d, num) => { ++ num = String(num); ++ ++ while (num.length < d) num = '0' + num; ++ ++ return num; ++}; ++ ++class FloatingDateTime extends Date { ++ constructor(value) { ++ super(value + 'Z'); ++ this.isFloating = true; ++ } ++ ++ toISOString() { ++ const date = `${this.getUTCFullYear()}-${formatNum(2, this.getUTCMonth() + 1)}-${formatNum(2, this.getUTCDate())}`; ++ const time = `${formatNum(2, this.getUTCHours())}:${formatNum(2, this.getUTCMinutes())}:${formatNum(2, this.getUTCSeconds())}.${formatNum(3, this.getUTCMilliseconds())}`; ++ return `${date}T${time}`; ++ } ++ ++} ++ ++var createDatetimeFloat = value => { ++ const date = new FloatingDateTime(value); ++ /* istanbul ignore if */ ++ ++ if (isNaN(date)) { ++ throw new TypeError('Invalid Datetime'); ++ } else { ++ return date; ++ } ++}; ++ ++const DateTime = global.Date; ++ ++class Date$1 extends DateTime { ++ constructor(value) { ++ super(value); ++ this.isDate = true; ++ } ++ ++ toISOString() { ++ return `${this.getUTCFullYear()}-${formatNum(2, this.getUTCMonth() + 1)}-${formatNum(2, this.getUTCDate())}`; ++ } ++ ++} ++ ++var createDate = value => { ++ const date = new Date$1(value); ++ /* istanbul ignore if */ ++ ++ if (isNaN(date)) { ++ throw new TypeError('Invalid Datetime'); ++ } else { ++ return date; ++ } ++}; ++ ++class Time extends Date { ++ constructor(value) { ++ super(`0000-01-01T${value}Z`); ++ this.isTime = true; ++ } ++ ++ toISOString() { ++ return `${formatNum(2, this.getUTCHours())}:${formatNum(2, this.getUTCMinutes())}:${formatNum(2, this.getUTCSeconds())}.${formatNum(3, this.getUTCMilliseconds())}`; ++ } ++ ++} ++ ++var createTime = value => { ++ const date = new Time(value); ++ /* istanbul ignore if */ ++ ++ if (isNaN(date)) { ++ throw new TypeError('Invalid Datetime'); ++ } else { ++ return date; ++ } ++}; ++ ++/* eslint-disable no-new-wrappers, no-eval, camelcase, operator-linebreak */ ++ ++ ++var tomlParser = makeParserClass(parser$1); ++var makeParserClass_1 = makeParserClass; ++ ++class TomlError extends Error { ++ constructor(msg) { ++ super(msg); ++ this.name = 'TomlError'; ++ /* istanbul ignore next */ ++ ++ if (Error.captureStackTrace) Error.captureStackTrace(this, TomlError); ++ this.fromTOML = true; ++ this.wrapped = null; ++ } ++ ++} ++ ++TomlError.wrap = err => { ++ const terr = new TomlError(err.message); ++ terr.code = err.code; ++ terr.wrapped = err; ++ return terr; ++}; ++ ++var TomlError_1 = TomlError; ++const CTRL_I = 0x09; ++const CTRL_J = 0x0A; ++const CTRL_M = 0x0D; ++const CTRL_CHAR_BOUNDARY = 0x1F; // the last non-character in the latin1 region of unicode, except DEL ++ ++const CHAR_SP = 0x20; ++const CHAR_QUOT = 0x22; ++const CHAR_NUM = 0x23; ++const CHAR_APOS = 0x27; ++const CHAR_PLUS = 0x2B; ++const CHAR_COMMA = 0x2C; ++const CHAR_HYPHEN = 0x2D; ++const CHAR_PERIOD = 0x2E; ++const CHAR_0 = 0x30; ++const CHAR_1 = 0x31; ++const CHAR_7 = 0x37; ++const CHAR_9 = 0x39; ++const CHAR_COLON = 0x3A; ++const CHAR_EQUALS = 0x3D; ++const CHAR_A = 0x41; ++const CHAR_E = 0x45; ++const CHAR_F = 0x46; ++const CHAR_T = 0x54; ++const CHAR_U = 0x55; ++const CHAR_Z = 0x5A; ++const CHAR_LOWBAR = 0x5F; ++const CHAR_a = 0x61; ++const CHAR_b = 0x62; ++const CHAR_e = 0x65; ++const CHAR_f = 0x66; ++const CHAR_i = 0x69; ++const CHAR_l = 0x6C; ++const CHAR_n = 0x6E; ++const CHAR_o = 0x6F; ++const CHAR_r = 0x72; ++const CHAR_s = 0x73; ++const CHAR_t = 0x74; ++const CHAR_u = 0x75; ++const CHAR_x = 0x78; ++const CHAR_z = 0x7A; ++const CHAR_LCUB = 0x7B; ++const CHAR_RCUB = 0x7D; ++const CHAR_LSQB = 0x5B; ++const CHAR_BSOL = 0x5C; ++const CHAR_RSQB = 0x5D; ++const CHAR_DEL = 0x7F; ++const SURROGATE_FIRST = 0xD800; ++const SURROGATE_LAST = 0xDFFF; ++const escapes = { ++ [CHAR_b]: '\u0008', ++ [CHAR_t]: '\u0009', ++ [CHAR_n]: '\u000A', ++ [CHAR_f]: '\u000C', ++ [CHAR_r]: '\u000D', ++ [CHAR_QUOT]: '\u0022', ++ [CHAR_BSOL]: '\u005C' ++}; ++ ++function isDigit(cp) { ++ return cp >= CHAR_0 && cp <= CHAR_9; ++} ++ ++function isHexit(cp) { ++ return cp >= CHAR_A && cp <= CHAR_F || cp >= CHAR_a && cp <= CHAR_f || cp >= CHAR_0 && cp <= CHAR_9; ++} ++ ++function isBit(cp) { ++ return cp === CHAR_1 || cp === CHAR_0; ++} ++ ++function isOctit(cp) { ++ return cp >= CHAR_0 && cp <= CHAR_7; ++} ++ ++function isAlphaNumQuoteHyphen(cp) { ++ return cp >= CHAR_A && cp <= CHAR_Z || cp >= CHAR_a && cp <= CHAR_z || cp >= CHAR_0 && cp <= CHAR_9 || cp === CHAR_APOS || cp === CHAR_QUOT || cp === CHAR_LOWBAR || cp === CHAR_HYPHEN; ++} ++ ++function isAlphaNumHyphen(cp) { ++ return cp >= CHAR_A && cp <= CHAR_Z || cp >= CHAR_a && cp <= CHAR_z || cp >= CHAR_0 && cp <= CHAR_9 || cp === CHAR_LOWBAR || cp === CHAR_HYPHEN; ++} ++ ++const _type = Symbol('type'); ++ ++const _declared = Symbol('declared'); ++ ++const hasOwnProperty$1 = Object.prototype.hasOwnProperty; ++const defineProperty = Object.defineProperty; ++const descriptor = { ++ configurable: true, ++ enumerable: true, ++ writable: true, ++ value: undefined ++}; ++ ++function hasKey(obj, key) { ++ if (hasOwnProperty$1.call(obj, key)) return true; ++ if (key === '__proto__') defineProperty(obj, '__proto__', descriptor); ++ return false; ++} ++ ++const INLINE_TABLE = Symbol('inline-table'); ++ ++function InlineTable() { ++ return Object.defineProperties({}, { ++ [_type]: { ++ value: INLINE_TABLE ++ } ++ }); ++} ++ ++function isInlineTable(obj) { ++ if (obj === null || typeof obj !== 'object') return false; ++ return obj[_type] === INLINE_TABLE; ++} ++ ++const TABLE = Symbol('table'); ++ ++function Table() { ++ return Object.defineProperties({}, { ++ [_type]: { ++ value: TABLE ++ }, ++ [_declared]: { ++ value: false, ++ writable: true ++ } ++ }); ++} ++ ++function isTable(obj) { ++ if (obj === null || typeof obj !== 'object') return false; ++ return obj[_type] === TABLE; ++} ++ ++const _contentType = Symbol('content-type'); ++ ++const INLINE_LIST = Symbol('inline-list'); ++ ++function InlineList(type) { ++ return Object.defineProperties([], { ++ [_type]: { ++ value: INLINE_LIST ++ }, ++ [_contentType]: { ++ value: type ++ } ++ }); ++} ++ ++function isInlineList(obj) { ++ if (obj === null || typeof obj !== 'object') return false; ++ return obj[_type] === INLINE_LIST; ++} ++ ++const LIST = Symbol('list'); ++ ++function List() { ++ return Object.defineProperties([], { ++ [_type]: { ++ value: LIST ++ } ++ }); ++} ++ ++function isList(obj) { ++ if (obj === null || typeof obj !== 'object') return false; ++ return obj[_type] === LIST; ++} // in an eval, to let bundlers not slurp in a util proxy ++ ++ ++let _custom; ++ ++try { ++ const utilInspect = eval("require('util').inspect"); ++ _custom = utilInspect.custom; ++} catch (_) {} ++/* eval require not available in transpiled bundle */ ++ ++/* istanbul ignore next */ ++ ++ ++const _inspect = _custom || 'inspect'; ++ ++class BoxedBigInt { ++ constructor(value) { ++ try { ++ this.value = global.BigInt.asIntN(64, value); ++ } catch (_) { ++ /* istanbul ignore next */ ++ this.value = null; ++ } ++ ++ Object.defineProperty(this, _type, { ++ value: INTEGER ++ }); ++ } ++ ++ isNaN() { ++ return this.value === null; ++ } ++ /* istanbul ignore next */ ++ ++ ++ toString() { ++ return String(this.value); ++ } ++ /* istanbul ignore next */ ++ ++ ++ [_inspect]() { ++ return `[BigInt: ${this.toString()}]}`; ++ } ++ ++ valueOf() { ++ return this.value; ++ } ++ ++} ++ ++const INTEGER = Symbol('integer'); ++ ++function Integer(value) { ++ let num = Number(value); // -0 is a float thing, not an int thing ++ ++ if (Object.is(num, -0)) num = 0; ++ /* istanbul ignore else */ ++ ++ if (global.BigInt && !Number.isSafeInteger(num)) { ++ return new BoxedBigInt(value); ++ } else { ++ /* istanbul ignore next */ ++ return Object.defineProperties(new Number(num), { ++ isNaN: { ++ value: function () { ++ return isNaN(this); ++ } ++ }, ++ [_type]: { ++ value: INTEGER ++ }, ++ [_inspect]: { ++ value: () => `[Integer: ${value}]` ++ } ++ }); ++ } ++} ++ ++function isInteger(obj) { ++ if (obj === null || typeof obj !== 'object') return false; ++ return obj[_type] === INTEGER; ++} ++ ++const FLOAT = Symbol('float'); ++ ++function Float(value) { ++ /* istanbul ignore next */ ++ return Object.defineProperties(new Number(value), { ++ [_type]: { ++ value: FLOAT ++ }, ++ [_inspect]: { ++ value: () => `[Float: ${value}]` ++ } ++ }); ++} ++ ++function isFloat(obj) { ++ if (obj === null || typeof obj !== 'object') return false; ++ return obj[_type] === FLOAT; ++} ++ ++function tomlType(value) { ++ const type = typeof value; ++ ++ if (type === 'object') { ++ /* istanbul ignore if */ ++ if (value === null) return 'null'; ++ if (value instanceof Date) return 'datetime'; ++ /* istanbul ignore else */ ++ ++ if (_type in value) { ++ switch (value[_type]) { ++ case INLINE_TABLE: ++ return 'inline-table'; ++ ++ case INLINE_LIST: ++ return 'inline-list'; ++ ++ /* istanbul ignore next */ ++ ++ case TABLE: ++ return 'table'; ++ ++ /* istanbul ignore next */ ++ ++ case LIST: ++ return 'list'; ++ ++ case FLOAT: ++ return 'float'; ++ ++ case INTEGER: ++ return 'integer'; ++ } ++ } ++ } ++ ++ return type; ++} ++ ++function makeParserClass(Parser) { ++ class TOMLParser extends Parser { ++ constructor() { ++ super(); ++ this.ctx = this.obj = Table(); ++ } ++ /* MATCH HELPER */ ++ ++ ++ atEndOfWord() { ++ return this.char === CHAR_NUM || this.char === CTRL_I || this.char === CHAR_SP || this.atEndOfLine(); ++ } ++ ++ atEndOfLine() { ++ return this.char === Parser.END || this.char === CTRL_J || this.char === CTRL_M; ++ } ++ ++ parseStart() { ++ if (this.char === Parser.END) { ++ return null; ++ } else if (this.char === CHAR_LSQB) { ++ return this.call(this.parseTableOrList); ++ } else if (this.char === CHAR_NUM) { ++ return this.call(this.parseComment); ++ } else if (this.char === CTRL_J || this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) { ++ return null; ++ } else if (isAlphaNumQuoteHyphen(this.char)) { ++ return this.callNow(this.parseAssignStatement); ++ } else { ++ throw this.error(new TomlError(`Unknown character "${this.char}"`)); ++ } ++ } // HELPER, this strips any whitespace and comments to the end of the line ++ // then RETURNS. Last state in a production. ++ ++ ++ parseWhitespaceToEOL() { ++ if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) { ++ return null; ++ } else if (this.char === CHAR_NUM) { ++ return this.goto(this.parseComment); ++ } else if (this.char === Parser.END || this.char === CTRL_J) { ++ return this.return(); ++ } else { ++ throw this.error(new TomlError('Unexpected character, expected only whitespace or comments till end of line')); ++ } ++ } ++ /* ASSIGNMENT: key = value */ ++ ++ ++ parseAssignStatement() { ++ return this.callNow(this.parseAssign, this.recordAssignStatement); ++ } ++ ++ recordAssignStatement(kv) { ++ let target = this.ctx; ++ let finalKey = kv.key.pop(); ++ ++ for (let kw of kv.key) { ++ if (hasKey(target, kw) && (!isTable(target[kw]) || target[kw][_declared])) { ++ throw this.error(new TomlError("Can't redefine existing key")); ++ } ++ ++ target = target[kw] = target[kw] || Table(); ++ } ++ ++ if (hasKey(target, finalKey)) { ++ throw this.error(new TomlError("Can't redefine existing key")); ++ } // unbox our numbers ++ ++ ++ if (isInteger(kv.value) || isFloat(kv.value)) { ++ target[finalKey] = kv.value.valueOf(); ++ } else { ++ target[finalKey] = kv.value; ++ } ++ ++ return this.goto(this.parseWhitespaceToEOL); ++ } ++ /* ASSSIGNMENT expression, key = value possibly inside an inline table */ ++ ++ ++ parseAssign() { ++ return this.callNow(this.parseKeyword, this.recordAssignKeyword); ++ } ++ ++ recordAssignKeyword(key) { ++ if (this.state.resultTable) { ++ this.state.resultTable.push(key); ++ } else { ++ this.state.resultTable = [key]; ++ } ++ ++ return this.goto(this.parseAssignKeywordPreDot); ++ } ++ ++ parseAssignKeywordPreDot() { ++ if (this.char === CHAR_PERIOD) { ++ return this.next(this.parseAssignKeywordPostDot); ++ } else if (this.char !== CHAR_SP && this.char !== CTRL_I) { ++ return this.goto(this.parseAssignEqual); ++ } ++ } ++ ++ parseAssignKeywordPostDot() { ++ if (this.char !== CHAR_SP && this.char !== CTRL_I) { ++ return this.callNow(this.parseKeyword, this.recordAssignKeyword); ++ } ++ } ++ ++ parseAssignEqual() { ++ if (this.char === CHAR_EQUALS) { ++ return this.next(this.parseAssignPreValue); ++ } else { ++ throw this.error(new TomlError('Invalid character, expected "="')); ++ } ++ } ++ ++ parseAssignPreValue() { ++ if (this.char === CHAR_SP || this.char === CTRL_I) { ++ return null; ++ } else { ++ return this.callNow(this.parseValue, this.recordAssignValue); ++ } ++ } ++ ++ recordAssignValue(value) { ++ return this.returnNow({ ++ key: this.state.resultTable, ++ value: value ++ }); ++ } ++ /* COMMENTS: #...eol */ ++ ++ ++ parseComment() { ++ do { ++ if (this.char === Parser.END || this.char === CTRL_J) { ++ return this.return(); ++ } ++ } while (this.nextChar()); ++ } ++ /* TABLES AND LISTS, [foo] and [[foo]] */ ++ ++ ++ parseTableOrList() { ++ if (this.char === CHAR_LSQB) { ++ this.next(this.parseList); ++ } else { ++ return this.goto(this.parseTable); ++ } ++ } ++ /* TABLE [foo.bar.baz] */ ++ ++ ++ parseTable() { ++ this.ctx = this.obj; ++ return this.goto(this.parseTableNext); ++ } ++ ++ parseTableNext() { ++ if (this.char === CHAR_SP || this.char === CTRL_I) { ++ return null; ++ } else { ++ return this.callNow(this.parseKeyword, this.parseTableMore); ++ } ++ } ++ ++ parseTableMore(keyword) { ++ if (this.char === CHAR_SP || this.char === CTRL_I) { ++ return null; ++ } else if (this.char === CHAR_RSQB) { ++ if (hasKey(this.ctx, keyword) && (!isTable(this.ctx[keyword]) || this.ctx[keyword][_declared])) { ++ throw this.error(new TomlError("Can't redefine existing key")); ++ } else { ++ this.ctx = this.ctx[keyword] = this.ctx[keyword] || Table(); ++ this.ctx[_declared] = true; ++ } ++ ++ return this.next(this.parseWhitespaceToEOL); ++ } else if (this.char === CHAR_PERIOD) { ++ if (!hasKey(this.ctx, keyword)) { ++ this.ctx = this.ctx[keyword] = Table(); ++ } else if (isTable(this.ctx[keyword])) { ++ this.ctx = this.ctx[keyword]; ++ } else if (isList(this.ctx[keyword])) { ++ this.ctx = this.ctx[keyword][this.ctx[keyword].length - 1]; ++ } else { ++ throw this.error(new TomlError("Can't redefine existing key")); ++ } ++ ++ return this.next(this.parseTableNext); ++ } else { ++ throw this.error(new TomlError('Unexpected character, expected whitespace, . or ]')); ++ } ++ } ++ /* LIST [[a.b.c]] */ ++ ++ ++ parseList() { ++ this.ctx = this.obj; ++ return this.goto(this.parseListNext); ++ } ++ ++ parseListNext() { ++ if (this.char === CHAR_SP || this.char === CTRL_I) { ++ return null; ++ } else { ++ return this.callNow(this.parseKeyword, this.parseListMore); ++ } ++ } ++ ++ parseListMore(keyword) { ++ if (this.char === CHAR_SP || this.char === CTRL_I) { ++ return null; ++ } else if (this.char === CHAR_RSQB) { ++ if (!hasKey(this.ctx, keyword)) { ++ this.ctx[keyword] = List(); ++ } ++ ++ if (isInlineList(this.ctx[keyword])) { ++ throw this.error(new TomlError("Can't extend an inline array")); ++ } else if (isList(this.ctx[keyword])) { ++ const next = Table(); ++ this.ctx[keyword].push(next); ++ this.ctx = next; ++ } else { ++ throw this.error(new TomlError("Can't redefine an existing key")); ++ } ++ ++ return this.next(this.parseListEnd); ++ } else if (this.char === CHAR_PERIOD) { ++ if (!hasKey(this.ctx, keyword)) { ++ this.ctx = this.ctx[keyword] = Table(); ++ } else if (isInlineList(this.ctx[keyword])) { ++ throw this.error(new TomlError("Can't extend an inline array")); ++ } else if (isInlineTable(this.ctx[keyword])) { ++ throw this.error(new TomlError("Can't extend an inline table")); ++ } else if (isList(this.ctx[keyword])) { ++ this.ctx = this.ctx[keyword][this.ctx[keyword].length - 1]; ++ } else if (isTable(this.ctx[keyword])) { ++ this.ctx = this.ctx[keyword]; ++ } else { ++ throw this.error(new TomlError("Can't redefine an existing key")); ++ } ++ ++ return this.next(this.parseListNext); ++ } else { ++ throw this.error(new TomlError('Unexpected character, expected whitespace, . or ]')); ++ } ++ } ++ ++ parseListEnd(keyword) { ++ if (this.char === CHAR_RSQB) { ++ return this.next(this.parseWhitespaceToEOL); ++ } else { ++ throw this.error(new TomlError('Unexpected character, expected whitespace, . or ]')); ++ } ++ } ++ /* VALUE string, number, boolean, inline list, inline object */ ++ ++ ++ parseValue() { ++ if (this.char === Parser.END) { ++ throw this.error(new TomlError('Key without value')); ++ } else if (this.char === CHAR_QUOT) { ++ return this.next(this.parseDoubleString); ++ } ++ ++ if (this.char === CHAR_APOS) { ++ return this.next(this.parseSingleString); ++ } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) { ++ return this.goto(this.parseNumberSign); ++ } else if (this.char === CHAR_i) { ++ return this.next(this.parseInf); ++ } else if (this.char === CHAR_n) { ++ return this.next(this.parseNan); ++ } else if (isDigit(this.char)) { ++ return this.goto(this.parseNumberOrDateTime); ++ } else if (this.char === CHAR_t || this.char === CHAR_f) { ++ return this.goto(this.parseBoolean); ++ } else if (this.char === CHAR_LSQB) { ++ return this.call(this.parseInlineList, this.recordValue); ++ } else if (this.char === CHAR_LCUB) { ++ return this.call(this.parseInlineTable, this.recordValue); ++ } else { ++ throw this.error(new TomlError('Unexpected character, expecting string, number, datetime, boolean, inline array or inline table')); ++ } ++ } ++ ++ recordValue(value) { ++ return this.returnNow(value); ++ } ++ ++ parseInf() { ++ if (this.char === CHAR_n) { ++ return this.next(this.parseInf2); ++ } else { ++ throw this.error(new TomlError('Unexpected character, expected "inf", "+inf" or "-inf"')); ++ } ++ } ++ ++ parseInf2() { ++ if (this.char === CHAR_f) { ++ if (this.state.buf === '-') { ++ return this.return(-Infinity); ++ } else { ++ return this.return(Infinity); ++ } ++ } else { ++ throw this.error(new TomlError('Unexpected character, expected "inf", "+inf" or "-inf"')); ++ } ++ } ++ ++ parseNan() { ++ if (this.char === CHAR_a) { ++ return this.next(this.parseNan2); ++ } else { ++ throw this.error(new TomlError('Unexpected character, expected "nan"')); ++ } ++ } ++ ++ parseNan2() { ++ if (this.char === CHAR_n) { ++ return this.return(NaN); ++ } else { ++ throw this.error(new TomlError('Unexpected character, expected "nan"')); ++ } ++ } ++ /* KEYS, barewords or basic, literal, or dotted */ ++ ++ ++ parseKeyword() { ++ if (this.char === CHAR_QUOT) { ++ return this.next(this.parseBasicString); ++ } else if (this.char === CHAR_APOS) { ++ return this.next(this.parseLiteralString); ++ } else { ++ return this.goto(this.parseBareKey); ++ } ++ } ++ /* KEYS: barewords */ ++ ++ ++ parseBareKey() { ++ do { ++ if (this.char === Parser.END) { ++ throw this.error(new TomlError('Key ended without value')); ++ } else if (isAlphaNumHyphen(this.char)) { ++ this.consume(); ++ } else if (this.state.buf.length === 0) { ++ throw this.error(new TomlError('Empty bare keys are not allowed')); ++ } else { ++ return this.returnNow(); ++ } ++ } while (this.nextChar()); ++ } ++ /* STRINGS, single quoted (literal) */ ++ ++ ++ parseSingleString() { ++ if (this.char === CHAR_APOS) { ++ return this.next(this.parseLiteralMultiStringMaybe); ++ } else { ++ return this.goto(this.parseLiteralString); ++ } ++ } ++ ++ parseLiteralString() { ++ do { ++ if (this.char === CHAR_APOS) { ++ return this.return(); ++ } else if (this.atEndOfLine()) { ++ throw this.error(new TomlError('Unterminated string')); ++ } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I) { ++ throw this.errorControlCharInString(); ++ } else { ++ this.consume(); ++ } ++ } while (this.nextChar()); ++ } ++ ++ parseLiteralMultiStringMaybe() { ++ if (this.char === CHAR_APOS) { ++ return this.next(this.parseLiteralMultiString); ++ } else { ++ return this.returnNow(); ++ } ++ } ++ ++ parseLiteralMultiString() { ++ if (this.char === CTRL_M) { ++ return null; ++ } else if (this.char === CTRL_J) { ++ return this.next(this.parseLiteralMultiStringContent); ++ } else { ++ return this.goto(this.parseLiteralMultiStringContent); ++ } ++ } ++ ++ parseLiteralMultiStringContent() { ++ do { ++ if (this.char === CHAR_APOS) { ++ return this.next(this.parseLiteralMultiEnd); ++ } else if (this.char === Parser.END) { ++ throw this.error(new TomlError('Unterminated multi-line string')); ++ } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I && this.char !== CTRL_J && this.char !== CTRL_M) { ++ throw this.errorControlCharInString(); ++ } else { ++ this.consume(); ++ } ++ } while (this.nextChar()); ++ } ++ ++ parseLiteralMultiEnd() { ++ if (this.char === CHAR_APOS) { ++ return this.next(this.parseLiteralMultiEnd2); ++ } else { ++ this.state.buf += "'"; ++ return this.goto(this.parseLiteralMultiStringContent); ++ } ++ } ++ ++ parseLiteralMultiEnd2() { ++ if (this.char === CHAR_APOS) { ++ return this.return(); ++ } else { ++ this.state.buf += "''"; ++ return this.goto(this.parseLiteralMultiStringContent); ++ } ++ } ++ /* STRINGS double quoted */ ++ ++ ++ parseDoubleString() { ++ if (this.char === CHAR_QUOT) { ++ return this.next(this.parseMultiStringMaybe); ++ } else { ++ return this.goto(this.parseBasicString); ++ } ++ } ++ ++ parseBasicString() { ++ do { ++ if (this.char === CHAR_BSOL) { ++ return this.call(this.parseEscape, this.recordEscapeReplacement); ++ } else if (this.char === CHAR_QUOT) { ++ return this.return(); ++ } else if (this.atEndOfLine()) { ++ throw this.error(new TomlError('Unterminated string')); ++ } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I) { ++ throw this.errorControlCharInString(); ++ } else { ++ this.consume(); ++ } ++ } while (this.nextChar()); ++ } ++ ++ recordEscapeReplacement(replacement) { ++ this.state.buf += replacement; ++ return this.goto(this.parseBasicString); ++ } ++ ++ parseMultiStringMaybe() { ++ if (this.char === CHAR_QUOT) { ++ return this.next(this.parseMultiString); ++ } else { ++ return this.returnNow(); ++ } ++ } ++ ++ parseMultiString() { ++ if (this.char === CTRL_M) { ++ return null; ++ } else if (this.char === CTRL_J) { ++ return this.next(this.parseMultiStringContent); ++ } else { ++ return this.goto(this.parseMultiStringContent); ++ } ++ } ++ ++ parseMultiStringContent() { ++ do { ++ if (this.char === CHAR_BSOL) { ++ return this.call(this.parseMultiEscape, this.recordMultiEscapeReplacement); ++ } else if (this.char === CHAR_QUOT) { ++ return this.next(this.parseMultiEnd); ++ } else if (this.char === Parser.END) { ++ throw this.error(new TomlError('Unterminated multi-line string')); ++ } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I && this.char !== CTRL_J && this.char !== CTRL_M) { ++ throw this.errorControlCharInString(); ++ } else { ++ this.consume(); ++ } ++ } while (this.nextChar()); ++ } ++ ++ errorControlCharInString() { ++ let displayCode = '\\u00'; ++ ++ if (this.char < 16) { ++ displayCode += '0'; ++ } ++ ++ displayCode += this.char.toString(16); ++ return this.error(new TomlError(`Control characters (codes < 0x1f and 0x7f) are not allowed in strings, use ${displayCode} instead`)); ++ } ++ ++ recordMultiEscapeReplacement(replacement) { ++ this.state.buf += replacement; ++ return this.goto(this.parseMultiStringContent); ++ } ++ ++ parseMultiEnd() { ++ if (this.char === CHAR_QUOT) { ++ return this.next(this.parseMultiEnd2); ++ } else { ++ this.state.buf += '"'; ++ return this.goto(this.parseMultiStringContent); ++ } ++ } ++ ++ parseMultiEnd2() { ++ if (this.char === CHAR_QUOT) { ++ return this.return(); ++ } else { ++ this.state.buf += '""'; ++ return this.goto(this.parseMultiStringContent); ++ } ++ } ++ ++ parseMultiEscape() { ++ if (this.char === CTRL_M || this.char === CTRL_J) { ++ return this.next(this.parseMultiTrim); ++ } else if (this.char === CHAR_SP || this.char === CTRL_I) { ++ return this.next(this.parsePreMultiTrim); ++ } else { ++ return this.goto(this.parseEscape); ++ } ++ } ++ ++ parsePreMultiTrim() { ++ if (this.char === CHAR_SP || this.char === CTRL_I) { ++ return null; ++ } else if (this.char === CTRL_M || this.char === CTRL_J) { ++ return this.next(this.parseMultiTrim); ++ } else { ++ throw this.error(new TomlError("Can't escape whitespace")); ++ } ++ } ++ ++ parseMultiTrim() { ++ // explicitly whitespace here, END should follow the same path as chars ++ if (this.char === CTRL_J || this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) { ++ return null; ++ } else { ++ return this.returnNow(); ++ } ++ } ++ ++ parseEscape() { ++ if (this.char in escapes) { ++ return this.return(escapes[this.char]); ++ } else if (this.char === CHAR_u) { ++ return this.call(this.parseSmallUnicode, this.parseUnicodeReturn); ++ } else if (this.char === CHAR_U) { ++ return this.call(this.parseLargeUnicode, this.parseUnicodeReturn); ++ } else { ++ throw this.error(new TomlError('Unknown escape character: ' + this.char)); ++ } ++ } ++ ++ parseUnicodeReturn(char) { ++ try { ++ const codePoint = parseInt(char, 16); ++ ++ if (codePoint >= SURROGATE_FIRST && codePoint <= SURROGATE_LAST) { ++ throw this.error(new TomlError('Invalid unicode, character in range 0xD800 - 0xDFFF is reserved')); ++ } ++ ++ return this.returnNow(String.fromCodePoint(codePoint)); ++ } catch (err) { ++ throw this.error(TomlError.wrap(err)); ++ } ++ } ++ ++ parseSmallUnicode() { ++ if (!isHexit(this.char)) { ++ throw this.error(new TomlError('Invalid character in unicode sequence, expected hex')); ++ } else { ++ this.consume(); ++ if (this.state.buf.length >= 4) return this.return(); ++ } ++ } ++ ++ parseLargeUnicode() { ++ if (!isHexit(this.char)) { ++ throw this.error(new TomlError('Invalid character in unicode sequence, expected hex')); ++ } else { ++ this.consume(); ++ if (this.state.buf.length >= 8) return this.return(); ++ } ++ } ++ /* NUMBERS */ ++ ++ ++ parseNumberSign() { ++ this.consume(); ++ return this.next(this.parseMaybeSignedInfOrNan); ++ } ++ ++ parseMaybeSignedInfOrNan() { ++ if (this.char === CHAR_i) { ++ return this.next(this.parseInf); ++ } else if (this.char === CHAR_n) { ++ return this.next(this.parseNan); ++ } else { ++ return this.callNow(this.parseNoUnder, this.parseNumberIntegerStart); ++ } ++ } ++ ++ parseNumberIntegerStart() { ++ if (this.char === CHAR_0) { ++ this.consume(); ++ return this.next(this.parseNumberIntegerExponentOrDecimal); ++ } else { ++ return this.goto(this.parseNumberInteger); ++ } ++ } ++ ++ parseNumberIntegerExponentOrDecimal() { ++ if (this.char === CHAR_PERIOD) { ++ this.consume(); ++ return this.call(this.parseNoUnder, this.parseNumberFloat); ++ } else if (this.char === CHAR_E || this.char === CHAR_e) { ++ this.consume(); ++ return this.next(this.parseNumberExponentSign); ++ } else { ++ return this.returnNow(Integer(this.state.buf)); ++ } ++ } ++ ++ parseNumberInteger() { ++ if (isDigit(this.char)) { ++ this.consume(); ++ } else if (this.char === CHAR_LOWBAR) { ++ return this.call(this.parseNoUnder); ++ } else if (this.char === CHAR_E || this.char === CHAR_e) { ++ this.consume(); ++ return this.next(this.parseNumberExponentSign); ++ } else if (this.char === CHAR_PERIOD) { ++ this.consume(); ++ return this.call(this.parseNoUnder, this.parseNumberFloat); ++ } else { ++ const result = Integer(this.state.buf); ++ /* istanbul ignore if */ ++ ++ if (result.isNaN()) { ++ throw this.error(new TomlError('Invalid number')); ++ } else { ++ return this.returnNow(result); ++ } ++ } ++ } ++ ++ parseNoUnder() { ++ if (this.char === CHAR_LOWBAR || this.char === CHAR_PERIOD || this.char === CHAR_E || this.char === CHAR_e) { ++ throw this.error(new TomlError('Unexpected character, expected digit')); ++ } else if (this.atEndOfWord()) { ++ throw this.error(new TomlError('Incomplete number')); ++ } ++ ++ return this.returnNow(); ++ } ++ ++ parseNumberFloat() { ++ if (this.char === CHAR_LOWBAR) { ++ return this.call(this.parseNoUnder, this.parseNumberFloat); ++ } else if (isDigit(this.char)) { ++ this.consume(); ++ } else if (this.char === CHAR_E || this.char === CHAR_e) { ++ this.consume(); ++ return this.next(this.parseNumberExponentSign); ++ } else { ++ return this.returnNow(Float(this.state.buf)); ++ } ++ } ++ ++ parseNumberExponentSign() { ++ if (isDigit(this.char)) { ++ return this.goto(this.parseNumberExponent); ++ } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) { ++ this.consume(); ++ this.call(this.parseNoUnder, this.parseNumberExponent); ++ } else { ++ throw this.error(new TomlError('Unexpected character, expected -, + or digit')); ++ } ++ } ++ ++ parseNumberExponent() { ++ if (isDigit(this.char)) { ++ this.consume(); ++ } else if (this.char === CHAR_LOWBAR) { ++ return this.call(this.parseNoUnder); ++ } else { ++ return this.returnNow(Float(this.state.buf)); ++ } ++ } ++ /* NUMBERS or DATETIMES */ ++ ++ ++ parseNumberOrDateTime() { ++ if (this.char === CHAR_0) { ++ this.consume(); ++ return this.next(this.parseNumberBaseOrDateTime); ++ } else { ++ return this.goto(this.parseNumberOrDateTimeOnly); ++ } ++ } ++ ++ parseNumberOrDateTimeOnly() { ++ // note, if two zeros are in a row then it MUST be a date ++ if (this.char === CHAR_LOWBAR) { ++ return this.call(this.parseNoUnder, this.parseNumberInteger); ++ } else if (isDigit(this.char)) { ++ this.consume(); ++ if (this.state.buf.length > 4) this.next(this.parseNumberInteger); ++ } else if (this.char === CHAR_E || this.char === CHAR_e) { ++ this.consume(); ++ return this.next(this.parseNumberExponentSign); ++ } else if (this.char === CHAR_PERIOD) { ++ this.consume(); ++ return this.call(this.parseNoUnder, this.parseNumberFloat); ++ } else if (this.char === CHAR_HYPHEN) { ++ return this.goto(this.parseDateTime); ++ } else if (this.char === CHAR_COLON) { ++ return this.goto(this.parseOnlyTimeHour); ++ } else { ++ return this.returnNow(Integer(this.state.buf)); ++ } ++ } ++ ++ parseDateTimeOnly() { ++ if (this.state.buf.length < 4) { ++ if (isDigit(this.char)) { ++ return this.consume(); ++ } else if (this.char === CHAR_COLON) { ++ return this.goto(this.parseOnlyTimeHour); ++ } else { ++ throw this.error(new TomlError('Expected digit while parsing year part of a date')); ++ } ++ } else { ++ if (this.char === CHAR_HYPHEN) { ++ return this.goto(this.parseDateTime); ++ } else { ++ throw this.error(new TomlError('Expected hyphen (-) while parsing year part of date')); ++ } ++ } ++ } ++ ++ parseNumberBaseOrDateTime() { ++ if (this.char === CHAR_b) { ++ this.consume(); ++ return this.call(this.parseNoUnder, this.parseIntegerBin); ++ } else if (this.char === CHAR_o) { ++ this.consume(); ++ return this.call(this.parseNoUnder, this.parseIntegerOct); ++ } else if (this.char === CHAR_x) { ++ this.consume(); ++ return this.call(this.parseNoUnder, this.parseIntegerHex); ++ } else if (this.char === CHAR_PERIOD) { ++ return this.goto(this.parseNumberInteger); ++ } else if (isDigit(this.char)) { ++ return this.goto(this.parseDateTimeOnly); ++ } else { ++ return this.returnNow(Integer(this.state.buf)); ++ } ++ } ++ ++ parseIntegerHex() { ++ if (isHexit(this.char)) { ++ this.consume(); ++ } else if (this.char === CHAR_LOWBAR) { ++ return this.call(this.parseNoUnder); ++ } else { ++ const result = Integer(this.state.buf); ++ /* istanbul ignore if */ ++ ++ if (result.isNaN()) { ++ throw this.error(new TomlError('Invalid number')); ++ } else { ++ return this.returnNow(result); ++ } ++ } ++ } ++ ++ parseIntegerOct() { ++ if (isOctit(this.char)) { ++ this.consume(); ++ } else if (this.char === CHAR_LOWBAR) { ++ return this.call(this.parseNoUnder); ++ } else { ++ const result = Integer(this.state.buf); ++ /* istanbul ignore if */ ++ ++ if (result.isNaN()) { ++ throw this.error(new TomlError('Invalid number')); ++ } else { ++ return this.returnNow(result); ++ } ++ } ++ } ++ ++ parseIntegerBin() { ++ if (isBit(this.char)) { ++ this.consume(); ++ } else if (this.char === CHAR_LOWBAR) { ++ return this.call(this.parseNoUnder); ++ } else { ++ const result = Integer(this.state.buf); ++ /* istanbul ignore if */ ++ ++ if (result.isNaN()) { ++ throw this.error(new TomlError('Invalid number')); ++ } else { ++ return this.returnNow(result); ++ } ++ } ++ } ++ /* DATETIME */ ++ ++ ++ parseDateTime() { ++ // we enter here having just consumed the year and about to consume the hyphen ++ if (this.state.buf.length < 4) { ++ throw this.error(new TomlError('Years less than 1000 must be zero padded to four characters')); ++ } ++ ++ this.state.result = this.state.buf; ++ this.state.buf = ''; ++ return this.next(this.parseDateMonth); ++ } ++ ++ parseDateMonth() { ++ if (this.char === CHAR_HYPHEN) { ++ if (this.state.buf.length < 2) { ++ throw this.error(new TomlError('Months less than 10 must be zero padded to two characters')); ++ } ++ ++ this.state.result += '-' + this.state.buf; ++ this.state.buf = ''; ++ return this.next(this.parseDateDay); ++ } else if (isDigit(this.char)) { ++ this.consume(); ++ } else { ++ throw this.error(new TomlError('Incomplete datetime')); ++ } ++ } ++ ++ parseDateDay() { ++ if (this.char === CHAR_T || this.char === CHAR_SP) { ++ if (this.state.buf.length < 2) { ++ throw this.error(new TomlError('Days less than 10 must be zero padded to two characters')); ++ } ++ ++ this.state.result += '-' + this.state.buf; ++ this.state.buf = ''; ++ return this.next(this.parseStartTimeHour); ++ } else if (this.atEndOfWord()) { ++ return this.return(createDate(this.state.result + '-' + this.state.buf)); ++ } else if (isDigit(this.char)) { ++ this.consume(); ++ } else { ++ throw this.error(new TomlError('Incomplete datetime')); ++ } ++ } ++ ++ parseStartTimeHour() { ++ if (this.atEndOfWord()) { ++ return this.returnNow(createDate(this.state.result)); ++ } else { ++ return this.goto(this.parseTimeHour); ++ } ++ } ++ ++ parseTimeHour() { ++ if (this.char === CHAR_COLON) { ++ if (this.state.buf.length < 2) { ++ throw this.error(new TomlError('Hours less than 10 must be zero padded to two characters')); ++ } ++ ++ this.state.result += 'T' + this.state.buf; ++ this.state.buf = ''; ++ return this.next(this.parseTimeMin); ++ } else if (isDigit(this.char)) { ++ this.consume(); ++ } else { ++ throw this.error(new TomlError('Incomplete datetime')); ++ } ++ } ++ ++ parseTimeMin() { ++ if (this.state.buf.length < 2 && isDigit(this.char)) { ++ this.consume(); ++ } else if (this.state.buf.length === 2 && this.char === CHAR_COLON) { ++ this.state.result += ':' + this.state.buf; ++ this.state.buf = ''; ++ return this.next(this.parseTimeSec); ++ } else { ++ throw this.error(new TomlError('Incomplete datetime')); ++ } ++ } ++ ++ parseTimeSec() { ++ if (isDigit(this.char)) { ++ this.consume(); ++ ++ if (this.state.buf.length === 2) { ++ this.state.result += ':' + this.state.buf; ++ this.state.buf = ''; ++ return this.next(this.parseTimeZoneOrFraction); ++ } ++ } else { ++ throw this.error(new TomlError('Incomplete datetime')); ++ } ++ } ++ ++ parseOnlyTimeHour() { ++ /* istanbul ignore else */ ++ if (this.char === CHAR_COLON) { ++ if (this.state.buf.length < 2) { ++ throw this.error(new TomlError('Hours less than 10 must be zero padded to two characters')); ++ } ++ ++ this.state.result = this.state.buf; ++ this.state.buf = ''; ++ return this.next(this.parseOnlyTimeMin); ++ } else { ++ throw this.error(new TomlError('Incomplete time')); ++ } ++ } ++ ++ parseOnlyTimeMin() { ++ if (this.state.buf.length < 2 && isDigit(this.char)) { ++ this.consume(); ++ } else if (this.state.buf.length === 2 && this.char === CHAR_COLON) { ++ this.state.result += ':' + this.state.buf; ++ this.state.buf = ''; ++ return this.next(this.parseOnlyTimeSec); ++ } else { ++ throw this.error(new TomlError('Incomplete time')); ++ } ++ } ++ ++ parseOnlyTimeSec() { ++ if (isDigit(this.char)) { ++ this.consume(); ++ ++ if (this.state.buf.length === 2) { ++ return this.next(this.parseOnlyTimeFractionMaybe); ++ } ++ } else { ++ throw this.error(new TomlError('Incomplete time')); ++ } ++ } ++ ++ parseOnlyTimeFractionMaybe() { ++ this.state.result += ':' + this.state.buf; ++ ++ if (this.char === CHAR_PERIOD) { ++ this.state.buf = ''; ++ this.next(this.parseOnlyTimeFraction); ++ } else { ++ return this.return(createTime(this.state.result)); ++ } ++ } ++ ++ parseOnlyTimeFraction() { ++ if (isDigit(this.char)) { ++ this.consume(); ++ } else if (this.atEndOfWord()) { ++ if (this.state.buf.length === 0) throw this.error(new TomlError('Expected digit in milliseconds')); ++ return this.returnNow(createTime(this.state.result + '.' + this.state.buf)); ++ } else { ++ throw this.error(new TomlError('Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z')); ++ } ++ } ++ ++ parseTimeZoneOrFraction() { ++ if (this.char === CHAR_PERIOD) { ++ this.consume(); ++ this.next(this.parseDateTimeFraction); ++ } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) { ++ this.consume(); ++ this.next(this.parseTimeZoneHour); ++ } else if (this.char === CHAR_Z) { ++ this.consume(); ++ return this.return(createDatetime(this.state.result + this.state.buf)); ++ } else if (this.atEndOfWord()) { ++ return this.returnNow(createDatetimeFloat(this.state.result + this.state.buf)); ++ } else { ++ throw this.error(new TomlError('Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z')); ++ } ++ } ++ ++ parseDateTimeFraction() { ++ if (isDigit(this.char)) { ++ this.consume(); ++ } else if (this.state.buf.length === 1) { ++ throw this.error(new TomlError('Expected digit in milliseconds')); ++ } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) { ++ this.consume(); ++ this.next(this.parseTimeZoneHour); ++ } else if (this.char === CHAR_Z) { ++ this.consume(); ++ return this.return(createDatetime(this.state.result + this.state.buf)); ++ } else if (this.atEndOfWord()) { ++ return this.returnNow(createDatetimeFloat(this.state.result + this.state.buf)); ++ } else { ++ throw this.error(new TomlError('Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z')); ++ } ++ } ++ ++ parseTimeZoneHour() { ++ if (isDigit(this.char)) { ++ this.consume(); // FIXME: No more regexps ++ ++ if (/\d\d$/.test(this.state.buf)) return this.next(this.parseTimeZoneSep); ++ } else { ++ throw this.error(new TomlError('Unexpected character in datetime, expected digit')); ++ } ++ } ++ ++ parseTimeZoneSep() { ++ if (this.char === CHAR_COLON) { ++ this.consume(); ++ this.next(this.parseTimeZoneMin); ++ } else { ++ throw this.error(new TomlError('Unexpected character in datetime, expected colon')); ++ } ++ } ++ ++ parseTimeZoneMin() { ++ if (isDigit(this.char)) { ++ this.consume(); ++ if (/\d\d$/.test(this.state.buf)) return this.return(createDatetime(this.state.result + this.state.buf)); ++ } else { ++ throw this.error(new TomlError('Unexpected character in datetime, expected digit')); ++ } ++ } ++ /* BOOLEAN */ ++ ++ ++ parseBoolean() { ++ /* istanbul ignore else */ ++ if (this.char === CHAR_t) { ++ this.consume(); ++ return this.next(this.parseTrue_r); ++ } else if (this.char === CHAR_f) { ++ this.consume(); ++ return this.next(this.parseFalse_a); ++ } ++ } ++ ++ parseTrue_r() { ++ if (this.char === CHAR_r) { ++ this.consume(); ++ return this.next(this.parseTrue_u); ++ } else { ++ throw this.error(new TomlError('Invalid boolean, expected true or false')); ++ } ++ } ++ ++ parseTrue_u() { ++ if (this.char === CHAR_u) { ++ this.consume(); ++ return this.next(this.parseTrue_e); ++ } else { ++ throw this.error(new TomlError('Invalid boolean, expected true or false')); ++ } ++ } ++ ++ parseTrue_e() { ++ if (this.char === CHAR_e) { ++ return this.return(true); ++ } else { ++ throw this.error(new TomlError('Invalid boolean, expected true or false')); ++ } ++ } ++ ++ parseFalse_a() { ++ if (this.char === CHAR_a) { ++ this.consume(); ++ return this.next(this.parseFalse_l); ++ } else { ++ throw this.error(new TomlError('Invalid boolean, expected true or false')); ++ } ++ } ++ ++ parseFalse_l() { ++ if (this.char === CHAR_l) { ++ this.consume(); ++ return this.next(this.parseFalse_s); ++ } else { ++ throw this.error(new TomlError('Invalid boolean, expected true or false')); ++ } ++ } ++ ++ parseFalse_s() { ++ if (this.char === CHAR_s) { ++ this.consume(); ++ return this.next(this.parseFalse_e); ++ } else { ++ throw this.error(new TomlError('Invalid boolean, expected true or false')); ++ } ++ } ++ ++ parseFalse_e() { ++ if (this.char === CHAR_e) { ++ return this.return(false); ++ } else { ++ throw this.error(new TomlError('Invalid boolean, expected true or false')); ++ } ++ } ++ /* INLINE LISTS */ ++ ++ ++ parseInlineList() { ++ if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M || this.char === CTRL_J) { ++ return null; ++ } else if (this.char === Parser.END) { ++ throw this.error(new TomlError('Unterminated inline array')); ++ } else if (this.char === CHAR_NUM) { ++ return this.call(this.parseComment); ++ } else if (this.char === CHAR_RSQB) { ++ return this.return(this.state.resultArr || InlineList()); ++ } else { ++ return this.callNow(this.parseValue, this.recordInlineListValue); ++ } ++ } ++ ++ recordInlineListValue(value) { ++ if (this.state.resultArr) { ++ const listType = this.state.resultArr[_contentType]; ++ const valueType = tomlType(value); ++ ++ if (listType !== valueType) { ++ throw this.error(new TomlError(`Inline lists must be a single type, not a mix of ${listType} and ${valueType}`)); ++ } ++ } else { ++ this.state.resultArr = InlineList(tomlType(value)); ++ } ++ ++ if (isFloat(value) || isInteger(value)) { ++ // unbox now that we've verified they're ok ++ this.state.resultArr.push(value.valueOf()); ++ } else { ++ this.state.resultArr.push(value); ++ } ++ ++ return this.goto(this.parseInlineListNext); ++ } ++ ++ parseInlineListNext() { ++ if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M || this.char === CTRL_J) { ++ return null; ++ } else if (this.char === CHAR_NUM) { ++ return this.call(this.parseComment); ++ } else if (this.char === CHAR_COMMA) { ++ return this.next(this.parseInlineList); ++ } else if (this.char === CHAR_RSQB) { ++ return this.goto(this.parseInlineList); ++ } else { ++ throw this.error(new TomlError('Invalid character, expected whitespace, comma (,) or close bracket (])')); ++ } ++ } ++ /* INLINE TABLE */ ++ ++ ++ parseInlineTable() { ++ if (this.char === CHAR_SP || this.char === CTRL_I) { ++ return null; ++ } else if (this.char === Parser.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) { ++ throw this.error(new TomlError('Unterminated inline array')); ++ } else if (this.char === CHAR_RCUB) { ++ return this.return(this.state.resultTable || InlineTable()); ++ } else { ++ if (!this.state.resultTable) this.state.resultTable = InlineTable(); ++ return this.callNow(this.parseAssign, this.recordInlineTableValue); ++ } ++ } ++ ++ recordInlineTableValue(kv) { ++ let target = this.state.resultTable; ++ let finalKey = kv.key.pop(); ++ ++ for (let kw of kv.key) { ++ if (hasKey(target, kw) && (!isTable(target[kw]) || target[kw][_declared])) { ++ throw this.error(new TomlError("Can't redefine existing key")); ++ } ++ ++ target = target[kw] = target[kw] || Table(); ++ } ++ ++ if (hasKey(target, finalKey)) { ++ throw this.error(new TomlError("Can't redefine existing key")); ++ } ++ ++ if (isInteger(kv.value) || isFloat(kv.value)) { ++ target[finalKey] = kv.value.valueOf(); ++ } else { ++ target[finalKey] = kv.value; ++ } ++ ++ return this.goto(this.parseInlineTableNext); ++ } ++ ++ parseInlineTableNext() { ++ if (this.char === CHAR_SP || this.char === CTRL_I) { ++ return null; ++ } else if (this.char === Parser.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) { ++ throw this.error(new TomlError('Unterminated inline array')); ++ } else if (this.char === CHAR_COMMA) { ++ return this.next(this.parseInlineTable); ++ } else if (this.char === CHAR_RCUB) { ++ return this.goto(this.parseInlineTable); ++ } else { ++ throw this.error(new TomlError('Invalid character, expected whitespace, comma (,) or close bracket (])')); ++ } ++ } ++ ++ } ++ ++ return TOMLParser; ++} ++tomlParser.makeParserClass = makeParserClass_1; ++tomlParser.TomlError = TomlError_1; ++ ++var parsePrettyError = prettyError; ++ ++function prettyError(err, buf) { ++ /* istanbul ignore if */ ++ if (err.pos == null || err.line == null) return err; ++ let msg = err.message; ++ msg += ` at row ${err.line + 1}, col ${err.col + 1}, pos ${err.pos}:\n`; ++ /* istanbul ignore else */ ++ ++ if (buf && buf.split) { ++ const lines = buf.split(/\n/); ++ const lineNumWidth = String(Math.min(lines.length, err.line + 3)).length; ++ let linePadding = ' '; ++ ++ while (linePadding.length < lineNumWidth) linePadding += ' '; ++ ++ for (let ii = Math.max(0, err.line - 1); ii < Math.min(lines.length, err.line + 2); ++ii) { ++ let lineNum = String(ii + 1); ++ if (lineNum.length < lineNumWidth) lineNum = ' ' + lineNum; ++ ++ if (err.line === ii) { ++ msg += lineNum + '> ' + lines[ii] + '\n'; ++ msg += linePadding + ' '; ++ ++ for (let hh = 0; hh < err.col; ++hh) { ++ msg += ' '; ++ } ++ ++ msg += '^\n'; ++ } else { ++ msg += lineNum + ': ' + lines[ii] + '\n'; ++ } ++ } ++ } ++ ++ err.message = msg + '\n'; ++ return err; ++} ++ ++var parseString_1 = parseString; ++ ++function parseString(str) { ++ if (global.Buffer && global.Buffer.isBuffer(str)) { ++ str = str.toString('utf8'); ++ } ++ ++ const parser = new tomlParser(); ++ ++ try { ++ parser.parse(str); ++ return parser.finish(); ++ } catch (err) { ++ throw parsePrettyError(err, str); ++ } ++} ++ ++var loadToml = function (filePath, content) { ++ try { ++ return parseString_1(content); ++ } catch (error) { ++ error.message = `TOML Error in ${filePath}:\n${error.message}`; ++ throw error; ++ } ++}; ++ ++const getExplorerMemoized = mem_1(opts => { ++ const cosmiconfig = thirdParty["cosmiconfig" + (opts.sync ? "Sync" : "")]; ++ const explorer = cosmiconfig("prettier", { ++ cache: opts.cache, ++ transform: result => { ++ if (result && result.config) { ++ if (typeof result.config === "string") { ++ const dir = path$1.dirname(result.filepath); ++ ++ try { ++ const modulePath = require.resolve(result.config, { ++ paths: [dir] ++ }); ++ ++ result.config = require(modulePath); ++ } catch (error) { ++ // Original message contains `__filename`, can't pass tests ++ error.message = `Cannot find module '${result.config}' from '${dir}'`; ++ throw error; ++ } ++ } ++ ++ if (typeof result.config !== "object") { ++ throw new Error("Config is only allowed to be an object, " + `but received ${typeof result.config} in "${result.filepath}"`); ++ } ++ ++ delete result.config.$schema; ++ } ++ ++ return result; ++ }, ++ searchPlaces: ["package.json", ".prettierrc", ".prettierrc.json", ".prettierrc.yaml", ".prettierrc.yml", ".prettierrc.js", "prettier.config.js", ".prettierrc.toml"], ++ loaders: { ++ ".toml": loadToml ++ } ++ }); ++ return explorer; ++}, { ++ cacheKey: JSON.stringify ++}); ++/** @param {{ cache: boolean, sync: boolean }} opts */ ++ ++function getExplorer(opts) { ++ // Normalize opts before passing to a memoized function ++ opts = Object.assign({ ++ sync: false, ++ cache: false ++ }, opts); ++ return getExplorerMemoized(opts); ++} ++ ++function _resolveConfig(filePath, opts, sync) { ++ opts = Object.assign({ ++ useCache: true ++ }, opts); ++ const loadOpts = { ++ cache: !!opts.useCache, ++ sync: !!sync, ++ editorconfig: !!opts.editorconfig ++ }; ++ const { ++ load, ++ search ++ } = getExplorer(loadOpts); ++ const loadEditorConfig = resolveConfigEditorconfig.getLoadFunction(loadOpts); ++ const arr = [opts.config ? load(opts.config) : search(filePath), loadEditorConfig(filePath)]; ++ ++ const unwrapAndMerge = ([result, editorConfigured]) => { ++ const merged = Object.assign({}, editorConfigured, {}, mergeOverrides(result, filePath)); ++ ["plugins", "pluginSearchDirs"].forEach(optionName => { ++ if (Array.isArray(merged[optionName])) { ++ merged[optionName] = merged[optionName].map(value => typeof value === "string" && value.startsWith(".") // relative path ++ ? path$1.resolve(path$1.dirname(result.filepath), value) : value); ++ } ++ }); ++ ++ if (!result && !editorConfigured) { ++ return null; ++ } ++ ++ return merged; ++ }; ++ ++ if (loadOpts.sync) { ++ return unwrapAndMerge(arr); ++ } ++ ++ return Promise.all(arr).then(unwrapAndMerge); ++} ++ ++const resolveConfig = (filePath, opts) => _resolveConfig(filePath, opts, false); ++ ++resolveConfig.sync = (filePath, opts) => _resolveConfig(filePath, opts, true); ++ ++function clearCache$1() { ++ mem_1.clear(getExplorerMemoized); ++ resolveConfigEditorconfig.clearCache(); ++} ++ ++async function resolveConfigFile(filePath) { ++ const { ++ search ++ } = getExplorer({ ++ sync: false ++ }); ++ const result = await search(filePath); ++ return result ? result.filepath : null; ++} ++ ++resolveConfigFile.sync = filePath => { ++ const { ++ search ++ } = getExplorer({ ++ sync: true ++ }); ++ const result = search(filePath); ++ return result ? result.filepath : null; ++}; ++ ++function mergeOverrides(configResult, filePath) { ++ const { ++ config, ++ filepath: configPath ++ } = configResult || {}; ++ ++ const _ref = config || {}, ++ { ++ overrides ++ } = _ref, ++ options = _objectWithoutPropertiesLoose(_ref, ["overrides"]); ++ ++ if (filePath && overrides) { ++ const relativeFilePath = path$1.relative(path$1.dirname(configPath), filePath); ++ ++ for (const override of overrides) { ++ if (pathMatchesGlobs(relativeFilePath, override.files, override.excludeFiles)) { ++ Object.assign(options, override.options); ++ } ++ } ++ } ++ ++ return options; ++} // Based on eslint: https://github.com/eslint/eslint/blob/master/lib/config/config-ops.js ++ ++ ++function pathMatchesGlobs(filePath, patterns, excludedPatterns) { ++ const patternList = [].concat(patterns); ++ const excludedPatternList = [].concat(excludedPatterns || []); ++ const opts = { ++ matchBase: true, ++ dot: true ++ }; ++ return patternList.some(pattern => minimatch_1(filePath, pattern, opts)) && !excludedPatternList.some(excludedPattern => minimatch_1(filePath, excludedPattern, opts)); ++} ++ ++var resolveConfig_1 = { ++ resolveConfig, ++ resolveConfigFile, ++ clearCache: clearCache$1 ++}; ++ ++/** ++ * @typedef {{ ignorePath?: string, withNodeModules?: boolean, plugins: object }} FileInfoOptions ++ * @typedef {{ ignored: boolean, inferredParser: string | null }} FileInfoResult ++ */ ++ ++/** ++ * @param {string} filePath ++ * @param {FileInfoOptions} opts ++ * @returns {Promise} ++ * ++ * Please note that prettier.getFileInfo() expects opts.plugins to be an array of paths, ++ * not an object. A transformation from this array to an object is automatically done ++ * internally by the method wrapper. See withPlugins() in index.js. ++ */ ++ ++ ++async function getFileInfo(filePath, opts) { ++ if (typeof filePath !== "string") { ++ throw new TypeError(`expect \`filePath\` to be a string, got \`${typeof filePath}\``); ++ } ++ ++ const ignorer = await createIgnorer_1(opts.ignorePath, opts.withNodeModules); ++ return _getFileInfo({ ++ ignorer, ++ filePath: normalizeFilePath(filePath, opts.ignorePath), ++ plugins: opts.plugins, ++ resolveConfig: opts.resolveConfig, ++ sync: false ++ }); ++} ++/** ++ * @param {string} filePath ++ * @param {FileInfoOptions} opts ++ * @returns {FileInfoResult} ++ */ ++ ++ ++getFileInfo.sync = function (filePath, opts) { ++ if (typeof filePath !== "string") { ++ throw new TypeError(`expect \`filePath\` to be a string, got \`${typeof filePath}\``); ++ } ++ ++ const ignorer = createIgnorer_1.sync(opts.ignorePath, opts.withNodeModules); ++ return _getFileInfo({ ++ ignorer, ++ filePath: normalizeFilePath(filePath, opts.ignorePath), ++ plugins: opts.plugins, ++ resolveConfig: opts.resolveConfig, ++ sync: true ++ }); ++}; ++ ++function _getFileInfo({ ++ ignorer, ++ filePath, ++ plugins, ++ resolveConfig = false, ++ sync = false ++}) { ++ const fileInfo = { ++ ignored: ignorer.ignores(filePath), ++ inferredParser: options$1.inferParser(filePath, plugins) || null ++ }; ++ ++ if (!fileInfo.inferredParser && resolveConfig) { ++ if (!sync) { ++ return resolveConfig_1.resolveConfig(filePath).then(resolvedConfig => { ++ if (resolvedConfig && resolvedConfig.parser) { ++ fileInfo.inferredParser = resolvedConfig.parser; ++ } ++ ++ return fileInfo; ++ }); ++ } ++ ++ const resolvedConfig = resolveConfig_1.resolveConfig.sync(filePath); ++ ++ if (resolvedConfig && resolvedConfig.parser) { ++ fileInfo.inferredParser = resolvedConfig.parser; ++ } ++ } ++ ++ return fileInfo; ++} ++ ++function normalizeFilePath(filePath, ignorePath) { ++ return ignorePath ? path$1.relative(path$1.dirname(ignorePath), filePath) : filePath; ++} ++ ++var getFileInfo_1 = getFileInfo; ++ ++/** ++ * Removes all key-value entries from the list cache. ++ * ++ * @private ++ * @name clear ++ * @memberOf ListCache ++ */ ++function listCacheClear() { ++ this.__data__ = []; ++ this.size = 0; ++} ++ ++var _listCacheClear = listCacheClear; ++ ++/** ++ * Performs a ++ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) ++ * comparison between two values to determine if they are equivalent. ++ * ++ * @static ++ * @memberOf _ ++ * @since 4.0.0 ++ * @category Lang ++ * @param {*} value The value to compare. ++ * @param {*} other The other value to compare. ++ * @returns {boolean} Returns `true` if the values are equivalent, else `false`. ++ * @example ++ * ++ * var object = { 'a': 1 }; ++ * var other = { 'a': 1 }; ++ * ++ * _.eq(object, object); ++ * // => true ++ * ++ * _.eq(object, other); ++ * // => false ++ * ++ * _.eq('a', 'a'); ++ * // => true ++ * ++ * _.eq('a', Object('a')); ++ * // => false ++ * ++ * _.eq(NaN, NaN); ++ * // => true ++ */ ++function eq(value, other) { ++ return value === other || value !== value && other !== other; ++} ++ ++var eq_1 = eq; ++ ++/** ++ * Gets the index at which the `key` is found in `array` of key-value pairs. ++ * ++ * @private ++ * @param {Array} array The array to inspect. ++ * @param {*} key The key to search for. ++ * @returns {number} Returns the index of the matched value, else `-1`. ++ */ ++ ++function assocIndexOf(array, key) { ++ var length = array.length; ++ ++ while (length--) { ++ if (eq_1(array[length][0], key)) { ++ return length; ++ } ++ } ++ ++ return -1; ++} ++ ++var _assocIndexOf = assocIndexOf; ++ ++/** Used for built-in method references. */ ++ ++var arrayProto = Array.prototype; ++/** Built-in value references. */ ++ ++var splice = arrayProto.splice; ++/** ++ * Removes `key` and its value from the list cache. ++ * ++ * @private ++ * @name delete ++ * @memberOf ListCache ++ * @param {string} key The key of the value to remove. ++ * @returns {boolean} Returns `true` if the entry was removed, else `false`. ++ */ ++ ++function listCacheDelete(key) { ++ var data = this.__data__, ++ index = _assocIndexOf(data, key); ++ ++ if (index < 0) { ++ return false; ++ } ++ ++ var lastIndex = data.length - 1; ++ ++ if (index == lastIndex) { ++ data.pop(); ++ } else { ++ splice.call(data, index, 1); ++ } ++ ++ --this.size; ++ return true; ++} ++ ++var _listCacheDelete = listCacheDelete; ++ ++/** ++ * Gets the list cache value for `key`. ++ * ++ * @private ++ * @name get ++ * @memberOf ListCache ++ * @param {string} key The key of the value to get. ++ * @returns {*} Returns the entry value. ++ */ ++ ++function listCacheGet(key) { ++ var data = this.__data__, ++ index = _assocIndexOf(data, key); ++ return index < 0 ? undefined : data[index][1]; ++} ++ ++var _listCacheGet = listCacheGet; ++ ++/** ++ * Checks if a list cache value for `key` exists. ++ * ++ * @private ++ * @name has ++ * @memberOf ListCache ++ * @param {string} key The key of the entry to check. ++ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. ++ */ ++ ++function listCacheHas(key) { ++ return _assocIndexOf(this.__data__, key) > -1; ++} ++ ++var _listCacheHas = listCacheHas; ++ ++/** ++ * Sets the list cache `key` to `value`. ++ * ++ * @private ++ * @name set ++ * @memberOf ListCache ++ * @param {string} key The key of the value to set. ++ * @param {*} value The value to set. ++ * @returns {Object} Returns the list cache instance. ++ */ ++ ++function listCacheSet(key, value) { ++ var data = this.__data__, ++ index = _assocIndexOf(data, key); ++ ++ if (index < 0) { ++ ++this.size; ++ data.push([key, value]); ++ } else { ++ data[index][1] = value; ++ } ++ ++ return this; ++} ++ ++var _listCacheSet = listCacheSet; ++ ++/** ++ * Creates an list cache object. ++ * ++ * @private ++ * @constructor ++ * @param {Array} [entries] The key-value pairs to cache. ++ */ ++ ++function ListCache(entries) { ++ var index = -1, ++ length = entries == null ? 0 : entries.length; ++ this.clear(); ++ ++ while (++index < length) { ++ var entry = entries[index]; ++ this.set(entry[0], entry[1]); ++ } ++} // Add methods to `ListCache`. ++ ++ ++ListCache.prototype.clear = _listCacheClear; ++ListCache.prototype['delete'] = _listCacheDelete; ++ListCache.prototype.get = _listCacheGet; ++ListCache.prototype.has = _listCacheHas; ++ListCache.prototype.set = _listCacheSet; ++var _ListCache = ListCache; ++ ++/** ++ * Removes all key-value entries from the stack. ++ * ++ * @private ++ * @name clear ++ * @memberOf Stack ++ */ ++ ++function stackClear() { ++ this.__data__ = new _ListCache(); ++ this.size = 0; ++} ++ ++var _stackClear = stackClear; ++ ++/** ++ * Removes `key` and its value from the stack. ++ * ++ * @private ++ * @name delete ++ * @memberOf Stack ++ * @param {string} key The key of the value to remove. ++ * @returns {boolean} Returns `true` if the entry was removed, else `false`. ++ */ ++function stackDelete(key) { ++ var data = this.__data__, ++ result = data['delete'](key); ++ this.size = data.size; ++ return result; ++} ++ ++var _stackDelete = stackDelete; ++ ++/** ++ * Gets the stack value for `key`. ++ * ++ * @private ++ * @name get ++ * @memberOf Stack ++ * @param {string} key The key of the value to get. ++ * @returns {*} Returns the entry value. ++ */ ++function stackGet(key) { ++ return this.__data__.get(key); ++} ++ ++var _stackGet = stackGet; ++ ++/** ++ * Checks if a stack value for `key` exists. ++ * ++ * @private ++ * @name has ++ * @memberOf Stack ++ * @param {string} key The key of the entry to check. ++ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. ++ */ ++function stackHas(key) { ++ return this.__data__.has(key); ++} ++ ++var _stackHas = stackHas; ++ ++/** Detect free variable `global` from Node.js. */ ++ ++var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; ++var _freeGlobal = freeGlobal; ++ ++/** Detect free variable `self`. */ ++ ++var freeSelf = typeof self == 'object' && self && self.Object === Object && self; ++/** Used as a reference to the global object. */ ++ ++var root = _freeGlobal || freeSelf || Function('return this')(); ++var _root = root; ++ ++/** Built-in value references. */ ++ ++var Symbol$1 = _root.Symbol; ++var _Symbol = Symbol$1; ++ ++/** Used for built-in method references. */ ++ ++var objectProto = Object.prototype; ++/** Used to check objects for own properties. */ ++ ++var hasOwnProperty$2 = objectProto.hasOwnProperty; ++/** ++ * Used to resolve the ++ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) ++ * of values. ++ */ ++ ++var nativeObjectToString = objectProto.toString; ++/** Built-in value references. */ ++ ++var symToStringTag = _Symbol ? _Symbol.toStringTag : undefined; ++/** ++ * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values. ++ * ++ * @private ++ * @param {*} value The value to query. ++ * @returns {string} Returns the raw `toStringTag`. ++ */ ++ ++function getRawTag(value) { ++ var isOwn = hasOwnProperty$2.call(value, symToStringTag), ++ tag = value[symToStringTag]; ++ ++ try { ++ value[symToStringTag] = undefined; ++ var unmasked = true; ++ } catch (e) {} ++ ++ var result = nativeObjectToString.call(value); ++ ++ if (unmasked) { ++ if (isOwn) { ++ value[symToStringTag] = tag; ++ } else { ++ delete value[symToStringTag]; ++ } ++ } ++ ++ return result; ++} ++ ++var _getRawTag = getRawTag; ++ ++/** Used for built-in method references. */ ++var objectProto$1 = Object.prototype; ++/** ++ * Used to resolve the ++ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) ++ * of values. ++ */ ++ ++var nativeObjectToString$1 = objectProto$1.toString; ++/** ++ * Converts `value` to a string using `Object.prototype.toString`. ++ * ++ * @private ++ * @param {*} value The value to convert. ++ * @returns {string} Returns the converted string. ++ */ ++ ++function objectToString(value) { ++ return nativeObjectToString$1.call(value); ++} ++ ++var _objectToString = objectToString; ++ ++/** `Object#toString` result references. */ ++ ++var nullTag = '[object Null]', ++ undefinedTag = '[object Undefined]'; ++/** Built-in value references. */ ++ ++var symToStringTag$1 = _Symbol ? _Symbol.toStringTag : undefined; ++/** ++ * The base implementation of `getTag` without fallbacks for buggy environments. ++ * ++ * @private ++ * @param {*} value The value to query. ++ * @returns {string} Returns the `toStringTag`. ++ */ ++ ++function baseGetTag(value) { ++ if (value == null) { ++ return value === undefined ? undefinedTag : nullTag; ++ } ++ ++ return symToStringTag$1 && symToStringTag$1 in Object(value) ? _getRawTag(value) : _objectToString(value); ++} ++ ++var _baseGetTag = baseGetTag; ++ ++/** ++ * Checks if `value` is the ++ * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) ++ * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) ++ * ++ * @static ++ * @memberOf _ ++ * @since 0.1.0 ++ * @category Lang ++ * @param {*} value The value to check. ++ * @returns {boolean} Returns `true` if `value` is an object, else `false`. ++ * @example ++ * ++ * _.isObject({}); ++ * // => true ++ * ++ * _.isObject([1, 2, 3]); ++ * // => true ++ * ++ * _.isObject(_.noop); ++ * // => true ++ * ++ * _.isObject(null); ++ * // => false ++ */ ++function isObject(value) { ++ var type = typeof value; ++ return value != null && (type == 'object' || type == 'function'); ++} ++ ++var isObject_1 = isObject; ++ ++/** `Object#toString` result references. */ ++ ++var asyncTag = '[object AsyncFunction]', ++ funcTag = '[object Function]', ++ genTag = '[object GeneratorFunction]', ++ proxyTag = '[object Proxy]'; ++/** ++ * Checks if `value` is classified as a `Function` object. ++ * ++ * @static ++ * @memberOf _ ++ * @since 0.1.0 ++ * @category Lang ++ * @param {*} value The value to check. ++ * @returns {boolean} Returns `true` if `value` is a function, else `false`. ++ * @example ++ * ++ * _.isFunction(_); ++ * // => true ++ * ++ * _.isFunction(/abc/); ++ * // => false ++ */ ++ ++function isFunction(value) { ++ if (!isObject_1(value)) { ++ return false; ++ } // The use of `Object#toString` avoids issues with the `typeof` operator ++ // in Safari 9 which returns 'object' for typed arrays and other constructors. ++ ++ ++ var tag = _baseGetTag(value); ++ return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag; ++} ++ ++var isFunction_1 = isFunction; ++ ++/** Used to detect overreaching core-js shims. */ ++ ++var coreJsData = _root['__core-js_shared__']; ++var _coreJsData = coreJsData; ++ ++/** Used to detect methods masquerading as native. */ ++ ++var maskSrcKey = function () { ++ var uid = /[^.]+$/.exec(_coreJsData && _coreJsData.keys && _coreJsData.keys.IE_PROTO || ''); ++ return uid ? 'Symbol(src)_1.' + uid : ''; ++}(); ++/** ++ * Checks if `func` has its source masked. ++ * ++ * @private ++ * @param {Function} func The function to check. ++ * @returns {boolean} Returns `true` if `func` is masked, else `false`. ++ */ ++ ++ ++function isMasked(func) { ++ return !!maskSrcKey && maskSrcKey in func; ++} ++ ++var _isMasked = isMasked; ++ ++/** Used for built-in method references. */ ++var funcProto = Function.prototype; ++/** Used to resolve the decompiled source of functions. */ ++ ++var funcToString = funcProto.toString; ++/** ++ * Converts `func` to its source code. ++ * ++ * @private ++ * @param {Function} func The function to convert. ++ * @returns {string} Returns the source code. ++ */ ++ ++function toSource(func) { ++ if (func != null) { ++ try { ++ return funcToString.call(func); ++ } catch (e) {} ++ ++ try { ++ return func + ''; ++ } catch (e) {} ++ } ++ ++ return ''; ++} ++ ++var _toSource = toSource; ++ ++/** ++ * Used to match `RegExp` ++ * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). ++ */ ++ ++var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; ++/** Used to detect host constructors (Safari). */ ++ ++var reIsHostCtor = /^\[object .+?Constructor\]$/; ++/** Used for built-in method references. */ ++ ++var funcProto$1 = Function.prototype, ++ objectProto$2 = Object.prototype; ++/** Used to resolve the decompiled source of functions. */ ++ ++var funcToString$1 = funcProto$1.toString; ++/** Used to check objects for own properties. */ ++ ++var hasOwnProperty$3 = objectProto$2.hasOwnProperty; ++/** Used to detect if a method is native. */ ++ ++var reIsNative = RegExp('^' + funcToString$1.call(hasOwnProperty$3).replace(reRegExpChar, '\\$&').replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'); ++/** ++ * The base implementation of `_.isNative` without bad shim checks. ++ * ++ * @private ++ * @param {*} value The value to check. ++ * @returns {boolean} Returns `true` if `value` is a native function, ++ * else `false`. ++ */ ++ ++function baseIsNative(value) { ++ if (!isObject_1(value) || _isMasked(value)) { ++ return false; ++ } ++ ++ var pattern = isFunction_1(value) ? reIsNative : reIsHostCtor; ++ return pattern.test(_toSource(value)); ++} ++ ++var _baseIsNative = baseIsNative; ++ ++/** ++ * Gets the value at `key` of `object`. ++ * ++ * @private ++ * @param {Object} [object] The object to query. ++ * @param {string} key The key of the property to get. ++ * @returns {*} Returns the property value. ++ */ ++function getValue(object, key) { ++ return object == null ? undefined : object[key]; ++} ++ ++var _getValue = getValue; ++ ++/** ++ * Gets the native function at `key` of `object`. ++ * ++ * @private ++ * @param {Object} object The object to query. ++ * @param {string} key The key of the method to get. ++ * @returns {*} Returns the function if it's native, else `undefined`. ++ */ ++ ++function getNative(object, key) { ++ var value = _getValue(object, key); ++ return _baseIsNative(value) ? value : undefined; ++} ++ ++var _getNative = getNative; ++ ++/* Built-in method references that are verified to be native. */ ++ ++var Map$1 = _getNative(_root, 'Map'); ++var _Map = Map$1; ++ ++/* Built-in method references that are verified to be native. */ ++ ++var nativeCreate = _getNative(Object, 'create'); ++var _nativeCreate = nativeCreate; ++ ++/** ++ * Removes all key-value entries from the hash. ++ * ++ * @private ++ * @name clear ++ * @memberOf Hash ++ */ ++ ++function hashClear() { ++ this.__data__ = _nativeCreate ? _nativeCreate(null) : {}; ++ this.size = 0; ++} ++ ++var _hashClear = hashClear; ++ ++/** ++ * Removes `key` and its value from the hash. ++ * ++ * @private ++ * @name delete ++ * @memberOf Hash ++ * @param {Object} hash The hash to modify. ++ * @param {string} key The key of the value to remove. ++ * @returns {boolean} Returns `true` if the entry was removed, else `false`. ++ */ ++function hashDelete(key) { ++ var result = this.has(key) && delete this.__data__[key]; ++ this.size -= result ? 1 : 0; ++ return result; ++} ++ ++var _hashDelete = hashDelete; ++ ++/** Used to stand-in for `undefined` hash values. */ ++ ++var HASH_UNDEFINED = '__lodash_hash_undefined__'; ++/** Used for built-in method references. */ ++ ++var objectProto$3 = Object.prototype; ++/** Used to check objects for own properties. */ ++ ++var hasOwnProperty$4 = objectProto$3.hasOwnProperty; ++/** ++ * Gets the hash value for `key`. ++ * ++ * @private ++ * @name get ++ * @memberOf Hash ++ * @param {string} key The key of the value to get. ++ * @returns {*} Returns the entry value. ++ */ ++ ++function hashGet(key) { ++ var data = this.__data__; ++ ++ if (_nativeCreate) { ++ var result = data[key]; ++ return result === HASH_UNDEFINED ? undefined : result; ++ } ++ ++ return hasOwnProperty$4.call(data, key) ? data[key] : undefined; ++} ++ ++var _hashGet = hashGet; ++ ++/** Used for built-in method references. */ ++ ++var objectProto$4 = Object.prototype; ++/** Used to check objects for own properties. */ ++ ++var hasOwnProperty$5 = objectProto$4.hasOwnProperty; ++/** ++ * Checks if a hash value for `key` exists. ++ * ++ * @private ++ * @name has ++ * @memberOf Hash ++ * @param {string} key The key of the entry to check. ++ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. ++ */ ++ ++function hashHas(key) { ++ var data = this.__data__; ++ return _nativeCreate ? data[key] !== undefined : hasOwnProperty$5.call(data, key); ++} ++ ++var _hashHas = hashHas; ++ ++/** Used to stand-in for `undefined` hash values. */ ++ ++var HASH_UNDEFINED$1 = '__lodash_hash_undefined__'; ++/** ++ * Sets the hash `key` to `value`. ++ * ++ * @private ++ * @name set ++ * @memberOf Hash ++ * @param {string} key The key of the value to set. ++ * @param {*} value The value to set. ++ * @returns {Object} Returns the hash instance. ++ */ ++ ++function hashSet(key, value) { ++ var data = this.__data__; ++ this.size += this.has(key) ? 0 : 1; ++ data[key] = _nativeCreate && value === undefined ? HASH_UNDEFINED$1 : value; ++ return this; ++} ++ ++var _hashSet = hashSet; ++ ++/** ++ * Creates a hash object. ++ * ++ * @private ++ * @constructor ++ * @param {Array} [entries] The key-value pairs to cache. ++ */ ++ ++function Hash(entries) { ++ var index = -1, ++ length = entries == null ? 0 : entries.length; ++ this.clear(); ++ ++ while (++index < length) { ++ var entry = entries[index]; ++ this.set(entry[0], entry[1]); ++ } ++} // Add methods to `Hash`. ++ ++ ++Hash.prototype.clear = _hashClear; ++Hash.prototype['delete'] = _hashDelete; ++Hash.prototype.get = _hashGet; ++Hash.prototype.has = _hashHas; ++Hash.prototype.set = _hashSet; ++var _Hash = Hash; ++ ++/** ++ * Removes all key-value entries from the map. ++ * ++ * @private ++ * @name clear ++ * @memberOf MapCache ++ */ ++ ++function mapCacheClear() { ++ this.size = 0; ++ this.__data__ = { ++ 'hash': new _Hash(), ++ 'map': new (_Map || _ListCache)(), ++ 'string': new _Hash() ++ }; ++} ++ ++var _mapCacheClear = mapCacheClear; ++ ++/** ++ * Checks if `value` is suitable for use as unique object key. ++ * ++ * @private ++ * @param {*} value The value to check. ++ * @returns {boolean} Returns `true` if `value` is suitable, else `false`. ++ */ ++function isKeyable(value) { ++ var type = typeof value; ++ return type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean' ? value !== '__proto__' : value === null; ++} ++ ++var _isKeyable = isKeyable; ++ ++/** ++ * Gets the data for `map`. ++ * ++ * @private ++ * @param {Object} map The map to query. ++ * @param {string} key The reference key. ++ * @returns {*} Returns the map data. ++ */ ++ ++function getMapData(map, key) { ++ var data = map.__data__; ++ return _isKeyable(key) ? data[typeof key == 'string' ? 'string' : 'hash'] : data.map; ++} ++ ++var _getMapData = getMapData; ++ ++/** ++ * Removes `key` and its value from the map. ++ * ++ * @private ++ * @name delete ++ * @memberOf MapCache ++ * @param {string} key The key of the value to remove. ++ * @returns {boolean} Returns `true` if the entry was removed, else `false`. ++ */ ++ ++function mapCacheDelete(key) { ++ var result = _getMapData(this, key)['delete'](key); ++ this.size -= result ? 1 : 0; ++ return result; ++} ++ ++var _mapCacheDelete = mapCacheDelete; ++ ++/** ++ * Gets the map value for `key`. ++ * ++ * @private ++ * @name get ++ * @memberOf MapCache ++ * @param {string} key The key of the value to get. ++ * @returns {*} Returns the entry value. ++ */ ++ ++function mapCacheGet(key) { ++ return _getMapData(this, key).get(key); ++} ++ ++var _mapCacheGet = mapCacheGet; ++ ++/** ++ * Checks if a map value for `key` exists. ++ * ++ * @private ++ * @name has ++ * @memberOf MapCache ++ * @param {string} key The key of the entry to check. ++ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. ++ */ ++ ++function mapCacheHas(key) { ++ return _getMapData(this, key).has(key); ++} ++ ++var _mapCacheHas = mapCacheHas; ++ ++/** ++ * Sets the map `key` to `value`. ++ * ++ * @private ++ * @name set ++ * @memberOf MapCache ++ * @param {string} key The key of the value to set. ++ * @param {*} value The value to set. ++ * @returns {Object} Returns the map cache instance. ++ */ ++ ++function mapCacheSet(key, value) { ++ var data = _getMapData(this, key), ++ size = data.size; ++ data.set(key, value); ++ this.size += data.size == size ? 0 : 1; ++ return this; ++} ++ ++var _mapCacheSet = mapCacheSet; ++ ++/** ++ * Creates a map cache object to store key-value pairs. ++ * ++ * @private ++ * @constructor ++ * @param {Array} [entries] The key-value pairs to cache. ++ */ ++ ++function MapCache(entries) { ++ var index = -1, ++ length = entries == null ? 0 : entries.length; ++ this.clear(); ++ ++ while (++index < length) { ++ var entry = entries[index]; ++ this.set(entry[0], entry[1]); ++ } ++} // Add methods to `MapCache`. ++ ++ ++MapCache.prototype.clear = _mapCacheClear; ++MapCache.prototype['delete'] = _mapCacheDelete; ++MapCache.prototype.get = _mapCacheGet; ++MapCache.prototype.has = _mapCacheHas; ++MapCache.prototype.set = _mapCacheSet; ++var _MapCache = MapCache; ++ ++/** Used as the size to enable large array optimizations. */ ++ ++var LARGE_ARRAY_SIZE = 200; ++/** ++ * Sets the stack `key` to `value`. ++ * ++ * @private ++ * @name set ++ * @memberOf Stack ++ * @param {string} key The key of the value to set. ++ * @param {*} value The value to set. ++ * @returns {Object} Returns the stack cache instance. ++ */ ++ ++function stackSet(key, value) { ++ var data = this.__data__; ++ ++ if (data instanceof _ListCache) { ++ var pairs = data.__data__; ++ ++ if (!_Map || pairs.length < LARGE_ARRAY_SIZE - 1) { ++ pairs.push([key, value]); ++ this.size = ++data.size; ++ return this; ++ } ++ ++ data = this.__data__ = new _MapCache(pairs); ++ } ++ ++ data.set(key, value); ++ this.size = data.size; ++ return this; ++} ++ ++var _stackSet = stackSet; ++ ++/** ++ * Creates a stack cache object to store key-value pairs. ++ * ++ * @private ++ * @constructor ++ * @param {Array} [entries] The key-value pairs to cache. ++ */ ++ ++function Stack(entries) { ++ var data = this.__data__ = new _ListCache(entries); ++ this.size = data.size; ++} // Add methods to `Stack`. ++ ++ ++Stack.prototype.clear = _stackClear; ++Stack.prototype['delete'] = _stackDelete; ++Stack.prototype.get = _stackGet; ++Stack.prototype.has = _stackHas; ++Stack.prototype.set = _stackSet; ++var _Stack = Stack; ++ ++/** Used to stand-in for `undefined` hash values. */ ++var HASH_UNDEFINED$2 = '__lodash_hash_undefined__'; ++/** ++ * Adds `value` to the array cache. ++ * ++ * @private ++ * @name add ++ * @memberOf SetCache ++ * @alias push ++ * @param {*} value The value to cache. ++ * @returns {Object} Returns the cache instance. ++ */ ++ ++function setCacheAdd(value) { ++ this.__data__.set(value, HASH_UNDEFINED$2); ++ ++ return this; ++} ++ ++var _setCacheAdd = setCacheAdd; ++ ++/** ++ * Checks if `value` is in the array cache. ++ * ++ * @private ++ * @name has ++ * @memberOf SetCache ++ * @param {*} value The value to search for. ++ * @returns {number} Returns `true` if `value` is found, else `false`. ++ */ ++function setCacheHas(value) { ++ return this.__data__.has(value); ++} ++ ++var _setCacheHas = setCacheHas; ++ ++/** ++ * ++ * Creates an array cache object to store unique values. ++ * ++ * @private ++ * @constructor ++ * @param {Array} [values] The values to cache. ++ */ ++ ++function SetCache(values) { ++ var index = -1, ++ length = values == null ? 0 : values.length; ++ this.__data__ = new _MapCache(); ++ ++ while (++index < length) { ++ this.add(values[index]); ++ } ++} // Add methods to `SetCache`. ++ ++ ++SetCache.prototype.add = SetCache.prototype.push = _setCacheAdd; ++SetCache.prototype.has = _setCacheHas; ++var _SetCache = SetCache; ++ ++/** ++ * A specialized version of `_.some` for arrays without support for iteratee ++ * shorthands. ++ * ++ * @private ++ * @param {Array} [array] The array to iterate over. ++ * @param {Function} predicate The function invoked per iteration. ++ * @returns {boolean} Returns `true` if any element passes the predicate check, ++ * else `false`. ++ */ ++function arraySome(array, predicate) { ++ var index = -1, ++ length = array == null ? 0 : array.length; ++ ++ while (++index < length) { ++ if (predicate(array[index], index, array)) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++ ++var _arraySome = arraySome; ++ ++/** ++ * Checks if a `cache` value for `key` exists. ++ * ++ * @private ++ * @param {Object} cache The cache to query. ++ * @param {string} key The key of the entry to check. ++ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. ++ */ ++function cacheHas(cache, key) { ++ return cache.has(key); ++} ++ ++var _cacheHas = cacheHas; ++ ++/** Used to compose bitmasks for value comparisons. */ ++ ++var COMPARE_PARTIAL_FLAG = 1, ++ COMPARE_UNORDERED_FLAG = 2; ++/** ++ * A specialized version of `baseIsEqualDeep` for arrays with support for ++ * partial deep comparisons. ++ * ++ * @private ++ * @param {Array} array The array to compare. ++ * @param {Array} other The other array to compare. ++ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. ++ * @param {Function} customizer The function to customize comparisons. ++ * @param {Function} equalFunc The function to determine equivalents of values. ++ * @param {Object} stack Tracks traversed `array` and `other` objects. ++ * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`. ++ */ ++ ++function equalArrays(array, other, bitmask, customizer, equalFunc, stack) { ++ var isPartial = bitmask & COMPARE_PARTIAL_FLAG, ++ arrLength = array.length, ++ othLength = other.length; ++ ++ if (arrLength != othLength && !(isPartial && othLength > arrLength)) { ++ return false; ++ } // Assume cyclic values are equal. ++ ++ ++ var stacked = stack.get(array); ++ ++ if (stacked && stack.get(other)) { ++ return stacked == other; ++ } ++ ++ var index = -1, ++ result = true, ++ seen = bitmask & COMPARE_UNORDERED_FLAG ? new _SetCache() : undefined; ++ stack.set(array, other); ++ stack.set(other, array); // Ignore non-index properties. ++ ++ while (++index < arrLength) { ++ var arrValue = array[index], ++ othValue = other[index]; ++ ++ if (customizer) { ++ var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack); ++ } ++ ++ if (compared !== undefined) { ++ if (compared) { ++ continue; ++ } ++ ++ result = false; ++ break; ++ } // Recursively compare arrays (susceptible to call stack limits). ++ ++ ++ if (seen) { ++ if (!_arraySome(other, function (othValue, othIndex) { ++ if (!_cacheHas(seen, othIndex) && (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) { ++ return seen.push(othIndex); ++ } ++ })) { ++ result = false; ++ break; ++ } ++ } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) { ++ result = false; ++ break; ++ } ++ } ++ ++ stack['delete'](array); ++ stack['delete'](other); ++ return result; ++} ++ ++var _equalArrays = equalArrays; ++ ++/** Built-in value references. */ ++ ++var Uint8Array = _root.Uint8Array; ++var _Uint8Array = Uint8Array; ++ ++/** ++ * Converts `map` to its key-value pairs. ++ * ++ * @private ++ * @param {Object} map The map to convert. ++ * @returns {Array} Returns the key-value pairs. ++ */ ++function mapToArray(map) { ++ var index = -1, ++ result = Array(map.size); ++ map.forEach(function (value, key) { ++ result[++index] = [key, value]; ++ }); ++ return result; ++} ++ ++var _mapToArray = mapToArray; ++ ++/** ++ * Converts `set` to an array of its values. ++ * ++ * @private ++ * @param {Object} set The set to convert. ++ * @returns {Array} Returns the values. ++ */ ++function setToArray(set) { ++ var index = -1, ++ result = Array(set.size); ++ set.forEach(function (value) { ++ result[++index] = value; ++ }); ++ return result; ++} ++ ++var _setToArray = setToArray; ++ ++/** Used to compose bitmasks for value comparisons. */ ++ ++var COMPARE_PARTIAL_FLAG$1 = 1, ++ COMPARE_UNORDERED_FLAG$1 = 2; ++/** `Object#toString` result references. */ ++ ++var boolTag = '[object Boolean]', ++ dateTag = '[object Date]', ++ errorTag = '[object Error]', ++ mapTag = '[object Map]', ++ numberTag = '[object Number]', ++ regexpTag = '[object RegExp]', ++ setTag = '[object Set]', ++ stringTag = '[object String]', ++ symbolTag = '[object Symbol]'; ++var arrayBufferTag = '[object ArrayBuffer]', ++ dataViewTag = '[object DataView]'; ++/** Used to convert symbols to primitives and strings. */ ++ ++var symbolProto = _Symbol ? _Symbol.prototype : undefined, ++ symbolValueOf = symbolProto ? symbolProto.valueOf : undefined; ++/** ++ * A specialized version of `baseIsEqualDeep` for comparing objects of ++ * the same `toStringTag`. ++ * ++ * **Note:** This function only supports comparing values with tags of ++ * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. ++ * ++ * @private ++ * @param {Object} object The object to compare. ++ * @param {Object} other The other object to compare. ++ * @param {string} tag The `toStringTag` of the objects to compare. ++ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. ++ * @param {Function} customizer The function to customize comparisons. ++ * @param {Function} equalFunc The function to determine equivalents of values. ++ * @param {Object} stack Tracks traversed `object` and `other` objects. ++ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. ++ */ ++ ++function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) { ++ switch (tag) { ++ case dataViewTag: ++ if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) { ++ return false; ++ } ++ ++ object = object.buffer; ++ other = other.buffer; ++ ++ case arrayBufferTag: ++ if (object.byteLength != other.byteLength || !equalFunc(new _Uint8Array(object), new _Uint8Array(other))) { ++ return false; ++ } ++ ++ return true; ++ ++ case boolTag: ++ case dateTag: ++ case numberTag: ++ // Coerce booleans to `1` or `0` and dates to milliseconds. ++ // Invalid dates are coerced to `NaN`. ++ return eq_1(+object, +other); ++ ++ case errorTag: ++ return object.name == other.name && object.message == other.message; ++ ++ case regexpTag: ++ case stringTag: ++ // Coerce regexes to strings and treat strings, primitives and objects, ++ // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring ++ // for more details. ++ return object == other + ''; ++ ++ case mapTag: ++ var convert = _mapToArray; ++ ++ case setTag: ++ var isPartial = bitmask & COMPARE_PARTIAL_FLAG$1; ++ convert || (convert = _setToArray); ++ ++ if (object.size != other.size && !isPartial) { ++ return false; ++ } // Assume cyclic values are equal. ++ ++ ++ var stacked = stack.get(object); ++ ++ if (stacked) { ++ return stacked == other; ++ } ++ ++ bitmask |= COMPARE_UNORDERED_FLAG$1; // Recursively compare objects (susceptible to call stack limits). ++ ++ stack.set(object, other); ++ var result = _equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack); ++ stack['delete'](object); ++ return result; ++ ++ case symbolTag: ++ if (symbolValueOf) { ++ return symbolValueOf.call(object) == symbolValueOf.call(other); ++ } ++ ++ } ++ ++ return false; ++} ++ ++var _equalByTag = equalByTag; ++ ++/** ++ * Appends the elements of `values` to `array`. ++ * ++ * @private ++ * @param {Array} array The array to modify. ++ * @param {Array} values The values to append. ++ * @returns {Array} Returns `array`. ++ */ ++function arrayPush(array, values) { ++ var index = -1, ++ length = values.length, ++ offset = array.length; ++ ++ while (++index < length) { ++ array[offset + index] = values[index]; ++ } ++ ++ return array; ++} ++ ++var _arrayPush = arrayPush; ++ ++/** ++ * Checks if `value` is classified as an `Array` object. ++ * ++ * @static ++ * @memberOf _ ++ * @since 0.1.0 ++ * @category Lang ++ * @param {*} value The value to check. ++ * @returns {boolean} Returns `true` if `value` is an array, else `false`. ++ * @example ++ * ++ * _.isArray([1, 2, 3]); ++ * // => true ++ * ++ * _.isArray(document.body.children); ++ * // => false ++ * ++ * _.isArray('abc'); ++ * // => false ++ * ++ * _.isArray(_.noop); ++ * // => false ++ */ ++var isArray$1 = Array.isArray; ++var isArray_1 = isArray$1; ++ ++/** ++ * The base implementation of `getAllKeys` and `getAllKeysIn` which uses ++ * `keysFunc` and `symbolsFunc` to get the enumerable property names and ++ * symbols of `object`. ++ * ++ * @private ++ * @param {Object} object The object to query. ++ * @param {Function} keysFunc The function to get the keys of `object`. ++ * @param {Function} symbolsFunc The function to get the symbols of `object`. ++ * @returns {Array} Returns the array of property names and symbols. ++ */ ++ ++function baseGetAllKeys(object, keysFunc, symbolsFunc) { ++ var result = keysFunc(object); ++ return isArray_1(object) ? result : _arrayPush(result, symbolsFunc(object)); ++} ++ ++var _baseGetAllKeys = baseGetAllKeys; ++ ++/** ++ * A specialized version of `_.filter` for arrays without support for ++ * iteratee shorthands. ++ * ++ * @private ++ * @param {Array} [array] The array to iterate over. ++ * @param {Function} predicate The function invoked per iteration. ++ * @returns {Array} Returns the new filtered array. ++ */ ++function arrayFilter(array, predicate) { ++ var index = -1, ++ length = array == null ? 0 : array.length, ++ resIndex = 0, ++ result = []; ++ ++ while (++index < length) { ++ var value = array[index]; ++ ++ if (predicate(value, index, array)) { ++ result[resIndex++] = value; ++ } ++ } ++ ++ return result; ++} ++ ++var _arrayFilter = arrayFilter; ++ ++/** ++ * This method returns a new empty array. ++ * ++ * @static ++ * @memberOf _ ++ * @since 4.13.0 ++ * @category Util ++ * @returns {Array} Returns the new empty array. ++ * @example ++ * ++ * var arrays = _.times(2, _.stubArray); ++ * ++ * console.log(arrays); ++ * // => [[], []] ++ * ++ * console.log(arrays[0] === arrays[1]); ++ * // => false ++ */ ++function stubArray() { ++ return []; ++} ++ ++var stubArray_1 = stubArray; ++ ++/** Used for built-in method references. */ ++ ++var objectProto$5 = Object.prototype; ++/** Built-in value references. */ ++ ++var propertyIsEnumerable = objectProto$5.propertyIsEnumerable; ++/* Built-in method references for those with the same name as other `lodash` methods. */ ++ ++var nativeGetSymbols = Object.getOwnPropertySymbols; ++/** ++ * Creates an array of the own enumerable symbols of `object`. ++ * ++ * @private ++ * @param {Object} object The object to query. ++ * @returns {Array} Returns the array of symbols. ++ */ ++ ++var getSymbols = !nativeGetSymbols ? stubArray_1 : function (object) { ++ if (object == null) { ++ return []; ++ } ++ ++ object = Object(object); ++ return _arrayFilter(nativeGetSymbols(object), function (symbol) { ++ return propertyIsEnumerable.call(object, symbol); ++ }); ++}; ++var _getSymbols = getSymbols; ++ ++/** ++ * The base implementation of `_.times` without support for iteratee shorthands ++ * or max array length checks. ++ * ++ * @private ++ * @param {number} n The number of times to invoke `iteratee`. ++ * @param {Function} iteratee The function invoked per iteration. ++ * @returns {Array} Returns the array of results. ++ */ ++function baseTimes(n, iteratee) { ++ var index = -1, ++ result = Array(n); ++ ++ while (++index < n) { ++ result[index] = iteratee(index); ++ } ++ ++ return result; ++} ++ ++var _baseTimes = baseTimes; ++ ++/** ++ * Checks if `value` is object-like. A value is object-like if it's not `null` ++ * and has a `typeof` result of "object". ++ * ++ * @static ++ * @memberOf _ ++ * @since 4.0.0 ++ * @category Lang ++ * @param {*} value The value to check. ++ * @returns {boolean} Returns `true` if `value` is object-like, else `false`. ++ * @example ++ * ++ * _.isObjectLike({}); ++ * // => true ++ * ++ * _.isObjectLike([1, 2, 3]); ++ * // => true ++ * ++ * _.isObjectLike(_.noop); ++ * // => false ++ * ++ * _.isObjectLike(null); ++ * // => false ++ */ ++function isObjectLike(value) { ++ return value != null && typeof value == 'object'; ++} ++ ++var isObjectLike_1 = isObjectLike; ++ ++/** `Object#toString` result references. */ ++ ++var argsTag = '[object Arguments]'; ++/** ++ * The base implementation of `_.isArguments`. ++ * ++ * @private ++ * @param {*} value The value to check. ++ * @returns {boolean} Returns `true` if `value` is an `arguments` object, ++ */ ++ ++function baseIsArguments(value) { ++ return isObjectLike_1(value) && _baseGetTag(value) == argsTag; ++} ++ ++var _baseIsArguments = baseIsArguments; ++ ++/** Used for built-in method references. */ ++ ++var objectProto$6 = Object.prototype; ++/** Used to check objects for own properties. */ ++ ++var hasOwnProperty$6 = objectProto$6.hasOwnProperty; ++/** Built-in value references. */ ++ ++var propertyIsEnumerable$1 = objectProto$6.propertyIsEnumerable; ++/** ++ * Checks if `value` is likely an `arguments` object. ++ * ++ * @static ++ * @memberOf _ ++ * @since 0.1.0 ++ * @category Lang ++ * @param {*} value The value to check. ++ * @returns {boolean} Returns `true` if `value` is an `arguments` object, ++ * else `false`. ++ * @example ++ * ++ * _.isArguments(function() { return arguments; }()); ++ * // => true ++ * ++ * _.isArguments([1, 2, 3]); ++ * // => false ++ */ ++ ++var isArguments = _baseIsArguments(function () { ++ return arguments; ++}()) ? _baseIsArguments : function (value) { ++ return isObjectLike_1(value) && hasOwnProperty$6.call(value, 'callee') && !propertyIsEnumerable$1.call(value, 'callee'); ++}; ++var isArguments_1 = isArguments; ++ ++/** ++ * This method returns `false`. ++ * ++ * @static ++ * @memberOf _ ++ * @since 4.13.0 ++ * @category Util ++ * @returns {boolean} Returns `false`. ++ * @example ++ * ++ * _.times(2, _.stubFalse); ++ * // => [false, false] ++ */ ++function stubFalse() { ++ return false; ++} ++ ++var stubFalse_1 = stubFalse; ++ ++var isBuffer_1 = createCommonjsModule(function (module, exports) { ++ /** Detect free variable `exports`. */ ++ var freeExports = exports && !exports.nodeType && exports; ++ /** Detect free variable `module`. */ ++ ++ var freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module; ++ /** Detect the popular CommonJS extension `module.exports`. */ ++ ++ var moduleExports = freeModule && freeModule.exports === freeExports; ++ /** Built-in value references. */ ++ ++ var Buffer = moduleExports ? _root.Buffer : undefined; ++ /* Built-in method references for those with the same name as other `lodash` methods. */ ++ ++ var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined; ++ /** ++ * Checks if `value` is a buffer. ++ * ++ * @static ++ * @memberOf _ ++ * @since 4.3.0 ++ * @category Lang ++ * @param {*} value The value to check. ++ * @returns {boolean} Returns `true` if `value` is a buffer, else `false`. ++ * @example ++ * ++ * _.isBuffer(new Buffer(2)); ++ * // => true ++ * ++ * _.isBuffer(new Uint8Array(2)); ++ * // => false ++ */ ++ ++ var isBuffer = nativeIsBuffer || stubFalse_1; ++ module.exports = isBuffer; ++}); ++ ++/** Used as references for various `Number` constants. */ ++var MAX_SAFE_INTEGER$2 = 9007199254740991; ++/** Used to detect unsigned integer values. */ ++ ++var reIsUint = /^(?:0|[1-9]\d*)$/; ++/** ++ * Checks if `value` is a valid array-like index. ++ * ++ * @private ++ * @param {*} value The value to check. ++ * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. ++ * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. ++ */ ++ ++function isIndex(value, length) { ++ var type = typeof value; ++ length = length == null ? MAX_SAFE_INTEGER$2 : length; ++ return !!length && (type == 'number' || type != 'symbol' && reIsUint.test(value)) && value > -1 && value % 1 == 0 && value < length; ++} ++ ++var _isIndex = isIndex; ++ ++/** Used as references for various `Number` constants. */ ++var MAX_SAFE_INTEGER$3 = 9007199254740991; ++/** ++ * Checks if `value` is a valid array-like length. ++ * ++ * **Note:** This method is loosely based on ++ * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). ++ * ++ * @static ++ * @memberOf _ ++ * @since 4.0.0 ++ * @category Lang ++ * @param {*} value The value to check. ++ * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. ++ * @example ++ * ++ * _.isLength(3); ++ * // => true ++ * ++ * _.isLength(Number.MIN_VALUE); ++ * // => false ++ * ++ * _.isLength(Infinity); ++ * // => false ++ * ++ * _.isLength('3'); ++ * // => false ++ */ ++ ++function isLength(value) { ++ return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER$3; ++} ++ ++var isLength_1 = isLength; ++ ++/** `Object#toString` result references. */ ++ ++var argsTag$1 = '[object Arguments]', ++ arrayTag = '[object Array]', ++ boolTag$1 = '[object Boolean]', ++ dateTag$1 = '[object Date]', ++ errorTag$1 = '[object Error]', ++ funcTag$1 = '[object Function]', ++ mapTag$1 = '[object Map]', ++ numberTag$1 = '[object Number]', ++ objectTag = '[object Object]', ++ regexpTag$1 = '[object RegExp]', ++ setTag$1 = '[object Set]', ++ stringTag$1 = '[object String]', ++ weakMapTag = '[object WeakMap]'; ++var arrayBufferTag$1 = '[object ArrayBuffer]', ++ dataViewTag$1 = '[object DataView]', ++ float32Tag = '[object Float32Array]', ++ float64Tag = '[object Float64Array]', ++ int8Tag = '[object Int8Array]', ++ int16Tag = '[object Int16Array]', ++ int32Tag = '[object Int32Array]', ++ uint8Tag = '[object Uint8Array]', ++ uint8ClampedTag = '[object Uint8ClampedArray]', ++ uint16Tag = '[object Uint16Array]', ++ uint32Tag = '[object Uint32Array]'; ++/** Used to identify `toStringTag` values of typed arrays. */ ++ ++var typedArrayTags = {}; ++typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true; ++typedArrayTags[argsTag$1] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag$1] = typedArrayTags[boolTag$1] = typedArrayTags[dataViewTag$1] = typedArrayTags[dateTag$1] = typedArrayTags[errorTag$1] = typedArrayTags[funcTag$1] = typedArrayTags[mapTag$1] = typedArrayTags[numberTag$1] = typedArrayTags[objectTag] = typedArrayTags[regexpTag$1] = typedArrayTags[setTag$1] = typedArrayTags[stringTag$1] = typedArrayTags[weakMapTag] = false; ++/** ++ * The base implementation of `_.isTypedArray` without Node.js optimizations. ++ * ++ * @private ++ * @param {*} value The value to check. ++ * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. ++ */ ++ ++function baseIsTypedArray(value) { ++ return isObjectLike_1(value) && isLength_1(value.length) && !!typedArrayTags[_baseGetTag(value)]; ++} ++ ++var _baseIsTypedArray = baseIsTypedArray; ++ ++/** ++ * The base implementation of `_.unary` without support for storing metadata. ++ * ++ * @private ++ * @param {Function} func The function to cap arguments for. ++ * @returns {Function} Returns the new capped function. ++ */ ++function baseUnary(func) { ++ return function (value) { ++ return func(value); ++ }; ++} ++ ++var _baseUnary = baseUnary; ++ ++var _nodeUtil = createCommonjsModule(function (module, exports) { ++ /** Detect free variable `exports`. */ ++ var freeExports = exports && !exports.nodeType && exports; ++ /** Detect free variable `module`. */ ++ ++ var freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module; ++ /** Detect the popular CommonJS extension `module.exports`. */ ++ ++ var moduleExports = freeModule && freeModule.exports === freeExports; ++ /** Detect free variable `process` from Node.js. */ ++ ++ var freeProcess = moduleExports && _freeGlobal.process; ++ /** Used to access faster Node.js helpers. */ ++ ++ var nodeUtil = function () { ++ try { ++ // Use `util.types` for Node.js 10+. ++ var types = freeModule && freeModule.require && freeModule.require('util').types; ++ ++ if (types) { ++ return types; ++ } // Legacy `process.binding('util')` for Node.js < 10. ++ ++ ++ return freeProcess && freeProcess.binding && freeProcess.binding('util'); ++ } catch (e) {} ++ }(); ++ ++ module.exports = nodeUtil; ++}); ++ ++/* Node.js helper references. */ ++ ++var nodeIsTypedArray = _nodeUtil && _nodeUtil.isTypedArray; ++/** ++ * Checks if `value` is classified as a typed array. ++ * ++ * @static ++ * @memberOf _ ++ * @since 3.0.0 ++ * @category Lang ++ * @param {*} value The value to check. ++ * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. ++ * @example ++ * ++ * _.isTypedArray(new Uint8Array); ++ * // => true ++ * ++ * _.isTypedArray([]); ++ * // => false ++ */ ++ ++var isTypedArray = nodeIsTypedArray ? _baseUnary(nodeIsTypedArray) : _baseIsTypedArray; ++var isTypedArray_1 = isTypedArray; ++ ++/** Used for built-in method references. */ ++ ++var objectProto$7 = Object.prototype; ++/** Used to check objects for own properties. */ ++ ++var hasOwnProperty$7 = objectProto$7.hasOwnProperty; ++/** ++ * Creates an array of the enumerable property names of the array-like `value`. ++ * ++ * @private ++ * @param {*} value The value to query. ++ * @param {boolean} inherited Specify returning inherited property names. ++ * @returns {Array} Returns the array of property names. ++ */ ++ ++function arrayLikeKeys(value, inherited) { ++ var isArr = isArray_1(value), ++ isArg = !isArr && isArguments_1(value), ++ isBuff = !isArr && !isArg && isBuffer_1(value), ++ isType = !isArr && !isArg && !isBuff && isTypedArray_1(value), ++ skipIndexes = isArr || isArg || isBuff || isType, ++ result = skipIndexes ? _baseTimes(value.length, String) : [], ++ length = result.length; ++ ++ for (var key in value) { ++ if ((inherited || hasOwnProperty$7.call(value, key)) && !(skipIndexes && ( // Safari 9 has enumerable `arguments.length` in strict mode. ++ key == 'length' || // Node.js 0.10 has enumerable non-index properties on buffers. ++ isBuff && (key == 'offset' || key == 'parent') || // PhantomJS 2 has enumerable non-index properties on typed arrays. ++ isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset') || // Skip index properties. ++ _isIndex(key, length)))) { ++ result.push(key); ++ } ++ } ++ ++ return result; ++} ++ ++var _arrayLikeKeys = arrayLikeKeys; ++ ++/** Used for built-in method references. */ ++var objectProto$8 = Object.prototype; ++/** ++ * Checks if `value` is likely a prototype object. ++ * ++ * @private ++ * @param {*} value The value to check. ++ * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. ++ */ ++ ++function isPrototype(value) { ++ var Ctor = value && value.constructor, ++ proto = typeof Ctor == 'function' && Ctor.prototype || objectProto$8; ++ return value === proto; ++} ++ ++var _isPrototype = isPrototype; ++ ++/** ++ * Creates a unary function that invokes `func` with its argument transformed. ++ * ++ * @private ++ * @param {Function} func The function to wrap. ++ * @param {Function} transform The argument transform. ++ * @returns {Function} Returns the new function. ++ */ ++function overArg(func, transform) { ++ return function (arg) { ++ return func(transform(arg)); ++ }; ++} ++ ++var _overArg = overArg; ++ ++/* Built-in method references for those with the same name as other `lodash` methods. */ ++ ++var nativeKeys = _overArg(Object.keys, Object); ++var _nativeKeys = nativeKeys; ++ ++/** Used for built-in method references. */ ++ ++var objectProto$9 = Object.prototype; ++/** Used to check objects for own properties. */ ++ ++var hasOwnProperty$8 = objectProto$9.hasOwnProperty; ++/** ++ * The base implementation of `_.keys` which doesn't treat sparse arrays as dense. ++ * ++ * @private ++ * @param {Object} object The object to query. ++ * @returns {Array} Returns the array of property names. ++ */ ++ ++function baseKeys(object) { ++ if (!_isPrototype(object)) { ++ return _nativeKeys(object); ++ } ++ ++ var result = []; ++ ++ for (var key in Object(object)) { ++ if (hasOwnProperty$8.call(object, key) && key != 'constructor') { ++ result.push(key); ++ } ++ } ++ ++ return result; ++} ++ ++var _baseKeys = baseKeys; ++ ++/** ++ * Checks if `value` is array-like. A value is considered array-like if it's ++ * not a function and has a `value.length` that's an integer greater than or ++ * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`. ++ * ++ * @static ++ * @memberOf _ ++ * @since 4.0.0 ++ * @category Lang ++ * @param {*} value The value to check. ++ * @returns {boolean} Returns `true` if `value` is array-like, else `false`. ++ * @example ++ * ++ * _.isArrayLike([1, 2, 3]); ++ * // => true ++ * ++ * _.isArrayLike(document.body.children); ++ * // => true ++ * ++ * _.isArrayLike('abc'); ++ * // => true ++ * ++ * _.isArrayLike(_.noop); ++ * // => false ++ */ ++ ++function isArrayLike(value) { ++ return value != null && isLength_1(value.length) && !isFunction_1(value); ++} ++ ++var isArrayLike_1 = isArrayLike; ++ ++/** ++ * Creates an array of the own enumerable property names of `object`. ++ * ++ * **Note:** Non-object values are coerced to objects. See the ++ * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) ++ * for more details. ++ * ++ * @static ++ * @since 0.1.0 ++ * @memberOf _ ++ * @category Object ++ * @param {Object} object The object to query. ++ * @returns {Array} Returns the array of property names. ++ * @example ++ * ++ * function Foo() { ++ * this.a = 1; ++ * this.b = 2; ++ * } ++ * ++ * Foo.prototype.c = 3; ++ * ++ * _.keys(new Foo); ++ * // => ['a', 'b'] (iteration order is not guaranteed) ++ * ++ * _.keys('hi'); ++ * // => ['0', '1'] ++ */ ++ ++function keys(object) { ++ return isArrayLike_1(object) ? _arrayLikeKeys(object) : _baseKeys(object); ++} ++ ++var keys_1 = keys; ++ ++/** ++ * Creates an array of own enumerable property names and symbols of `object`. ++ * ++ * @private ++ * @param {Object} object The object to query. ++ * @returns {Array} Returns the array of property names and symbols. ++ */ ++ ++function getAllKeys(object) { ++ return _baseGetAllKeys(object, keys_1, _getSymbols); ++} ++ ++var _getAllKeys = getAllKeys; ++ ++/** Used to compose bitmasks for value comparisons. */ ++ ++var COMPARE_PARTIAL_FLAG$2 = 1; ++/** Used for built-in method references. */ ++ ++var objectProto$a = Object.prototype; ++/** Used to check objects for own properties. */ ++ ++var hasOwnProperty$9 = objectProto$a.hasOwnProperty; ++/** ++ * A specialized version of `baseIsEqualDeep` for objects with support for ++ * partial deep comparisons. ++ * ++ * @private ++ * @param {Object} object The object to compare. ++ * @param {Object} other The other object to compare. ++ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. ++ * @param {Function} customizer The function to customize comparisons. ++ * @param {Function} equalFunc The function to determine equivalents of values. ++ * @param {Object} stack Tracks traversed `object` and `other` objects. ++ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. ++ */ ++ ++function equalObjects(object, other, bitmask, customizer, equalFunc, stack) { ++ var isPartial = bitmask & COMPARE_PARTIAL_FLAG$2, ++ objProps = _getAllKeys(object), ++ objLength = objProps.length, ++ othProps = _getAllKeys(other), ++ othLength = othProps.length; ++ ++ if (objLength != othLength && !isPartial) { ++ return false; ++ } ++ ++ var index = objLength; ++ ++ while (index--) { ++ var key = objProps[index]; ++ ++ if (!(isPartial ? key in other : hasOwnProperty$9.call(other, key))) { ++ return false; ++ } ++ } // Assume cyclic values are equal. ++ ++ ++ var stacked = stack.get(object); ++ ++ if (stacked && stack.get(other)) { ++ return stacked == other; ++ } ++ ++ var result = true; ++ stack.set(object, other); ++ stack.set(other, object); ++ var skipCtor = isPartial; ++ ++ while (++index < objLength) { ++ key = objProps[index]; ++ var objValue = object[key], ++ othValue = other[key]; ++ ++ if (customizer) { ++ var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack); ++ } // Recursively compare objects (susceptible to call stack limits). ++ ++ ++ if (!(compared === undefined ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) { ++ result = false; ++ break; ++ } ++ ++ skipCtor || (skipCtor = key == 'constructor'); ++ } ++ ++ if (result && !skipCtor) { ++ var objCtor = object.constructor, ++ othCtor = other.constructor; // Non `Object` object instances with different constructors are not equal. ++ ++ if (objCtor != othCtor && 'constructor' in object && 'constructor' in other && !(typeof objCtor == 'function' && objCtor instanceof objCtor && typeof othCtor == 'function' && othCtor instanceof othCtor)) { ++ result = false; ++ } ++ } ++ ++ stack['delete'](object); ++ stack['delete'](other); ++ return result; ++} ++ ++var _equalObjects = equalObjects; ++ ++/* Built-in method references that are verified to be native. */ ++ ++var DataView = _getNative(_root, 'DataView'); ++var _DataView = DataView; ++ ++/* Built-in method references that are verified to be native. */ ++ ++var Promise$1 = _getNative(_root, 'Promise'); ++var _Promise = Promise$1; ++ ++/* Built-in method references that are verified to be native. */ ++ ++var Set$1 = _getNative(_root, 'Set'); ++var _Set = Set$1; ++ ++/* Built-in method references that are verified to be native. */ ++ ++var WeakMap$1 = _getNative(_root, 'WeakMap'); ++var _WeakMap = WeakMap$1; ++ ++/** `Object#toString` result references. */ ++ ++var mapTag$2 = '[object Map]', ++ objectTag$1 = '[object Object]', ++ promiseTag = '[object Promise]', ++ setTag$2 = '[object Set]', ++ weakMapTag$1 = '[object WeakMap]'; ++var dataViewTag$2 = '[object DataView]'; ++/** Used to detect maps, sets, and weakmaps. */ ++ ++var dataViewCtorString = _toSource(_DataView), ++ mapCtorString = _toSource(_Map), ++ promiseCtorString = _toSource(_Promise), ++ setCtorString = _toSource(_Set), ++ weakMapCtorString = _toSource(_WeakMap); ++/** ++ * Gets the `toStringTag` of `value`. ++ * ++ * @private ++ * @param {*} value The value to query. ++ * @returns {string} Returns the `toStringTag`. ++ */ ++ ++var getTag = _baseGetTag; // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6. ++ ++if (_DataView && getTag(new _DataView(new ArrayBuffer(1))) != dataViewTag$2 || _Map && getTag(new _Map()) != mapTag$2 || _Promise && getTag(_Promise.resolve()) != promiseTag || _Set && getTag(new _Set()) != setTag$2 || _WeakMap && getTag(new _WeakMap()) != weakMapTag$1) { ++ getTag = function (value) { ++ var result = _baseGetTag(value), ++ Ctor = result == objectTag$1 ? value.constructor : undefined, ++ ctorString = Ctor ? _toSource(Ctor) : ''; ++ ++ if (ctorString) { ++ switch (ctorString) { ++ case dataViewCtorString: ++ return dataViewTag$2; ++ ++ case mapCtorString: ++ return mapTag$2; ++ ++ case promiseCtorString: ++ return promiseTag; ++ ++ case setCtorString: ++ return setTag$2; ++ ++ case weakMapCtorString: ++ return weakMapTag$1; ++ } ++ } ++ ++ return result; ++ }; ++} ++ ++var _getTag = getTag; ++ ++/** Used to compose bitmasks for value comparisons. */ ++ ++var COMPARE_PARTIAL_FLAG$3 = 1; ++/** `Object#toString` result references. */ ++ ++var argsTag$2 = '[object Arguments]', ++ arrayTag$1 = '[object Array]', ++ objectTag$2 = '[object Object]'; ++/** Used for built-in method references. */ ++ ++var objectProto$b = Object.prototype; ++/** Used to check objects for own properties. */ ++ ++var hasOwnProperty$a = objectProto$b.hasOwnProperty; ++/** ++ * A specialized version of `baseIsEqual` for arrays and objects which performs ++ * deep comparisons and tracks traversed objects enabling objects with circular ++ * references to be compared. ++ * ++ * @private ++ * @param {Object} object The object to compare. ++ * @param {Object} other The other object to compare. ++ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. ++ * @param {Function} customizer The function to customize comparisons. ++ * @param {Function} equalFunc The function to determine equivalents of values. ++ * @param {Object} [stack] Tracks traversed `object` and `other` objects. ++ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. ++ */ ++ ++function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) { ++ var objIsArr = isArray_1(object), ++ othIsArr = isArray_1(other), ++ objTag = objIsArr ? arrayTag$1 : _getTag(object), ++ othTag = othIsArr ? arrayTag$1 : _getTag(other); ++ objTag = objTag == argsTag$2 ? objectTag$2 : objTag; ++ othTag = othTag == argsTag$2 ? objectTag$2 : othTag; ++ var objIsObj = objTag == objectTag$2, ++ othIsObj = othTag == objectTag$2, ++ isSameTag = objTag == othTag; ++ ++ if (isSameTag && isBuffer_1(object)) { ++ if (!isBuffer_1(other)) { ++ return false; ++ } ++ ++ objIsArr = true; ++ objIsObj = false; ++ } ++ ++ if (isSameTag && !objIsObj) { ++ stack || (stack = new _Stack()); ++ return objIsArr || isTypedArray_1(object) ? _equalArrays(object, other, bitmask, customizer, equalFunc, stack) : _equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack); ++ } ++ ++ if (!(bitmask & COMPARE_PARTIAL_FLAG$3)) { ++ var objIsWrapped = objIsObj && hasOwnProperty$a.call(object, '__wrapped__'), ++ othIsWrapped = othIsObj && hasOwnProperty$a.call(other, '__wrapped__'); ++ ++ if (objIsWrapped || othIsWrapped) { ++ var objUnwrapped = objIsWrapped ? object.value() : object, ++ othUnwrapped = othIsWrapped ? other.value() : other; ++ stack || (stack = new _Stack()); ++ return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack); ++ } ++ } ++ ++ if (!isSameTag) { ++ return false; ++ } ++ ++ stack || (stack = new _Stack()); ++ return _equalObjects(object, other, bitmask, customizer, equalFunc, stack); ++} ++ ++var _baseIsEqualDeep = baseIsEqualDeep; ++ ++/** ++ * The base implementation of `_.isEqual` which supports partial comparisons ++ * and tracks traversed objects. ++ * ++ * @private ++ * @param {*} value The value to compare. ++ * @param {*} other The other value to compare. ++ * @param {boolean} bitmask The bitmask flags. ++ * 1 - Unordered comparison ++ * 2 - Partial comparison ++ * @param {Function} [customizer] The function to customize comparisons. ++ * @param {Object} [stack] Tracks traversed `value` and `other` objects. ++ * @returns {boolean} Returns `true` if the values are equivalent, else `false`. ++ */ ++ ++function baseIsEqual(value, other, bitmask, customizer, stack) { ++ if (value === other) { ++ return true; ++ } ++ ++ if (value == null || other == null || !isObjectLike_1(value) && !isObjectLike_1(other)) { ++ return value !== value && other !== other; ++ } ++ ++ return _baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack); ++} ++ ++var _baseIsEqual = baseIsEqual; ++ ++/** Used to compose bitmasks for value comparisons. */ ++ ++var COMPARE_PARTIAL_FLAG$4 = 1, ++ COMPARE_UNORDERED_FLAG$2 = 2; ++/** ++ * The base implementation of `_.isMatch` without support for iteratee shorthands. ++ * ++ * @private ++ * @param {Object} object The object to inspect. ++ * @param {Object} source The object of property values to match. ++ * @param {Array} matchData The property names, values, and compare flags to match. ++ * @param {Function} [customizer] The function to customize comparisons. ++ * @returns {boolean} Returns `true` if `object` is a match, else `false`. ++ */ ++ ++function baseIsMatch(object, source, matchData, customizer) { ++ var index = matchData.length, ++ length = index, ++ noCustomizer = !customizer; ++ ++ if (object == null) { ++ return !length; ++ } ++ ++ object = Object(object); ++ ++ while (index--) { ++ var data = matchData[index]; ++ ++ if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) { ++ return false; ++ } ++ } ++ ++ while (++index < length) { ++ data = matchData[index]; ++ var key = data[0], ++ objValue = object[key], ++ srcValue = data[1]; ++ ++ if (noCustomizer && data[2]) { ++ if (objValue === undefined && !(key in object)) { ++ return false; ++ } ++ } else { ++ var stack = new _Stack(); ++ ++ if (customizer) { ++ var result = customizer(objValue, srcValue, key, object, source, stack); ++ } ++ ++ if (!(result === undefined ? _baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG$4 | COMPARE_UNORDERED_FLAG$2, customizer, stack) : result)) { ++ return false; ++ } ++ } ++ } ++ ++ return true; ++} ++ ++var _baseIsMatch = baseIsMatch; ++ ++/** ++ * Checks if `value` is suitable for strict equality comparisons, i.e. `===`. ++ * ++ * @private ++ * @param {*} value The value to check. ++ * @returns {boolean} Returns `true` if `value` if suitable for strict ++ * equality comparisons, else `false`. ++ */ ++ ++function isStrictComparable(value) { ++ return value === value && !isObject_1(value); ++} ++ ++var _isStrictComparable = isStrictComparable; ++ ++/** ++ * Gets the property names, values, and compare flags of `object`. ++ * ++ * @private ++ * @param {Object} object The object to query. ++ * @returns {Array} Returns the match data of `object`. ++ */ ++ ++function getMatchData(object) { ++ var result = keys_1(object), ++ length = result.length; ++ ++ while (length--) { ++ var key = result[length], ++ value = object[key]; ++ result[length] = [key, value, _isStrictComparable(value)]; ++ } ++ ++ return result; ++} ++ ++var _getMatchData = getMatchData; ++ ++/** ++ * A specialized version of `matchesProperty` for source values suitable ++ * for strict equality comparisons, i.e. `===`. ++ * ++ * @private ++ * @param {string} key The key of the property to get. ++ * @param {*} srcValue The value to match. ++ * @returns {Function} Returns the new spec function. ++ */ ++function matchesStrictComparable(key, srcValue) { ++ return function (object) { ++ if (object == null) { ++ return false; ++ } ++ ++ return object[key] === srcValue && (srcValue !== undefined || key in Object(object)); ++ }; ++} ++ ++var _matchesStrictComparable = matchesStrictComparable; ++ ++/** ++ * The base implementation of `_.matches` which doesn't clone `source`. ++ * ++ * @private ++ * @param {Object} source The object of property values to match. ++ * @returns {Function} Returns the new spec function. ++ */ ++ ++function baseMatches(source) { ++ var matchData = _getMatchData(source); ++ ++ if (matchData.length == 1 && matchData[0][2]) { ++ return _matchesStrictComparable(matchData[0][0], matchData[0][1]); ++ } ++ ++ return function (object) { ++ return object === source || _baseIsMatch(object, source, matchData); ++ }; ++} ++ ++var _baseMatches = baseMatches; ++ ++/** `Object#toString` result references. */ ++ ++var symbolTag$1 = '[object Symbol]'; ++/** ++ * Checks if `value` is classified as a `Symbol` primitive or object. ++ * ++ * @static ++ * @memberOf _ ++ * @since 4.0.0 ++ * @category Lang ++ * @param {*} value The value to check. ++ * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. ++ * @example ++ * ++ * _.isSymbol(Symbol.iterator); ++ * // => true ++ * ++ * _.isSymbol('abc'); ++ * // => false ++ */ ++ ++function isSymbol(value) { ++ return typeof value == 'symbol' || isObjectLike_1(value) && _baseGetTag(value) == symbolTag$1; ++} ++ ++var isSymbol_1 = isSymbol; ++ ++/** Used to match property names within property paths. */ ++ ++var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, ++ reIsPlainProp = /^\w*$/; ++/** ++ * Checks if `value` is a property name and not a property path. ++ * ++ * @private ++ * @param {*} value The value to check. ++ * @param {Object} [object] The object to query keys on. ++ * @returns {boolean} Returns `true` if `value` is a property name, else `false`. ++ */ ++ ++function isKey(value, object) { ++ if (isArray_1(value)) { ++ return false; ++ } ++ ++ var type = typeof value; ++ ++ if (type == 'number' || type == 'symbol' || type == 'boolean' || value == null || isSymbol_1(value)) { ++ return true; ++ } ++ ++ return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object); ++} ++ ++var _isKey = isKey; ++ ++/** Error message constants. */ ++ ++var FUNC_ERROR_TEXT = 'Expected a function'; ++/** ++ * Creates a function that memoizes the result of `func`. If `resolver` is ++ * provided, it determines the cache key for storing the result based on the ++ * arguments provided to the memoized function. By default, the first argument ++ * provided to the memoized function is used as the map cache key. The `func` ++ * is invoked with the `this` binding of the memoized function. ++ * ++ * **Note:** The cache is exposed as the `cache` property on the memoized ++ * function. Its creation may be customized by replacing the `_.memoize.Cache` ++ * constructor with one whose instances implement the ++ * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object) ++ * method interface of `clear`, `delete`, `get`, `has`, and `set`. ++ * ++ * @static ++ * @memberOf _ ++ * @since 0.1.0 ++ * @category Function ++ * @param {Function} func The function to have its output memoized. ++ * @param {Function} [resolver] The function to resolve the cache key. ++ * @returns {Function} Returns the new memoized function. ++ * @example ++ * ++ * var object = { 'a': 1, 'b': 2 }; ++ * var other = { 'c': 3, 'd': 4 }; ++ * ++ * var values = _.memoize(_.values); ++ * values(object); ++ * // => [1, 2] ++ * ++ * values(other); ++ * // => [3, 4] ++ * ++ * object.a = 2; ++ * values(object); ++ * // => [1, 2] ++ * ++ * // Modify the result cache. ++ * values.cache.set(object, ['a', 'b']); ++ * values(object); ++ * // => ['a', 'b'] ++ * ++ * // Replace `_.memoize.Cache`. ++ * _.memoize.Cache = WeakMap; ++ */ ++ ++function memoize(func, resolver) { ++ if (typeof func != 'function' || resolver != null && typeof resolver != 'function') { ++ throw new TypeError(FUNC_ERROR_TEXT); ++ } ++ ++ var memoized = function () { ++ var args = arguments, ++ key = resolver ? resolver.apply(this, args) : args[0], ++ cache = memoized.cache; ++ ++ if (cache.has(key)) { ++ return cache.get(key); ++ } ++ ++ var result = func.apply(this, args); ++ memoized.cache = cache.set(key, result) || cache; ++ return result; ++ }; ++ ++ memoized.cache = new (memoize.Cache || _MapCache)(); ++ return memoized; ++} // Expose `MapCache`. ++ ++ ++memoize.Cache = _MapCache; ++var memoize_1 = memoize; ++ ++/** Used as the maximum memoize cache size. */ ++ ++var MAX_MEMOIZE_SIZE = 500; ++/** ++ * A specialized version of `_.memoize` which clears the memoized function's ++ * cache when it exceeds `MAX_MEMOIZE_SIZE`. ++ * ++ * @private ++ * @param {Function} func The function to have its output memoized. ++ * @returns {Function} Returns the new memoized function. ++ */ ++ ++function memoizeCapped(func) { ++ var result = memoize_1(func, function (key) { ++ if (cache.size === MAX_MEMOIZE_SIZE) { ++ cache.clear(); ++ } ++ ++ return key; ++ }); ++ var cache = result.cache; ++ return result; ++} ++ ++var _memoizeCapped = memoizeCapped; ++ ++/** Used to match property names within property paths. */ ++ ++var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; ++/** Used to match backslashes in property paths. */ ++ ++var reEscapeChar = /\\(\\)?/g; ++/** ++ * Converts `string` to a property path array. ++ * ++ * @private ++ * @param {string} string The string to convert. ++ * @returns {Array} Returns the property path array. ++ */ ++ ++var stringToPath = _memoizeCapped(function (string) { ++ var result = []; ++ ++ if (string.charCodeAt(0) === 46 ++ /* . */ ++ ) { ++ result.push(''); ++ } ++ ++ string.replace(rePropName, function (match, number, quote, subString) { ++ result.push(quote ? subString.replace(reEscapeChar, '$1') : number || match); ++ }); ++ return result; ++}); ++var _stringToPath = stringToPath; ++ ++/** ++ * A specialized version of `_.map` for arrays without support for iteratee ++ * shorthands. ++ * ++ * @private ++ * @param {Array} [array] The array to iterate over. ++ * @param {Function} iteratee The function invoked per iteration. ++ * @returns {Array} Returns the new mapped array. ++ */ ++function arrayMap(array, iteratee) { ++ var index = -1, ++ length = array == null ? 0 : array.length, ++ result = Array(length); ++ ++ while (++index < length) { ++ result[index] = iteratee(array[index], index, array); ++ } ++ ++ return result; ++} ++ ++var _arrayMap = arrayMap; ++ ++/** Used as references for various `Number` constants. */ ++ ++var INFINITY = 1 / 0; ++/** Used to convert symbols to primitives and strings. */ ++ ++var symbolProto$1 = _Symbol ? _Symbol.prototype : undefined, ++ symbolToString = symbolProto$1 ? symbolProto$1.toString : undefined; ++/** ++ * The base implementation of `_.toString` which doesn't convert nullish ++ * values to empty strings. ++ * ++ * @private ++ * @param {*} value The value to process. ++ * @returns {string} Returns the string. ++ */ ++ ++function baseToString(value) { ++ // Exit early for strings to avoid a performance hit in some environments. ++ if (typeof value == 'string') { ++ return value; ++ } ++ ++ if (isArray_1(value)) { ++ // Recursively convert values (susceptible to call stack limits). ++ return _arrayMap(value, baseToString) + ''; ++ } ++ ++ if (isSymbol_1(value)) { ++ return symbolToString ? symbolToString.call(value) : ''; ++ } ++ ++ var result = value + ''; ++ return result == '0' && 1 / value == -INFINITY ? '-0' : result; ++} ++ ++var _baseToString = baseToString; ++ ++/** ++ * Converts `value` to a string. An empty string is returned for `null` ++ * and `undefined` values. The sign of `-0` is preserved. ++ * ++ * @static ++ * @memberOf _ ++ * @since 4.0.0 ++ * @category Lang ++ * @param {*} value The value to convert. ++ * @returns {string} Returns the converted string. ++ * @example ++ * ++ * _.toString(null); ++ * // => '' ++ * ++ * _.toString(-0); ++ * // => '-0' ++ * ++ * _.toString([1, 2, 3]); ++ * // => '1,2,3' ++ */ ++ ++function toString(value) { ++ return value == null ? '' : _baseToString(value); ++} ++ ++var toString_1 = toString; ++ ++/** ++ * Casts `value` to a path array if it's not one. ++ * ++ * @private ++ * @param {*} value The value to inspect. ++ * @param {Object} [object] The object to query keys on. ++ * @returns {Array} Returns the cast property path array. ++ */ ++ ++function castPath(value, object) { ++ if (isArray_1(value)) { ++ return value; ++ } ++ ++ return _isKey(value, object) ? [value] : _stringToPath(toString_1(value)); ++} ++ ++var _castPath = castPath; ++ ++/** Used as references for various `Number` constants. */ ++ ++var INFINITY$1 = 1 / 0; ++/** ++ * Converts `value` to a string key if it's not a string or symbol. ++ * ++ * @private ++ * @param {*} value The value to inspect. ++ * @returns {string|symbol} Returns the key. ++ */ ++ ++function toKey(value) { ++ if (typeof value == 'string' || isSymbol_1(value)) { ++ return value; ++ } ++ ++ var result = value + ''; ++ return result == '0' && 1 / value == -INFINITY$1 ? '-0' : result; ++} ++ ++var _toKey = toKey; ++ ++/** ++ * The base implementation of `_.get` without support for default values. ++ * ++ * @private ++ * @param {Object} object The object to query. ++ * @param {Array|string} path The path of the property to get. ++ * @returns {*} Returns the resolved value. ++ */ ++ ++function baseGet(object, path) { ++ path = _castPath(path, object); ++ var index = 0, ++ length = path.length; ++ ++ while (object != null && index < length) { ++ object = object[_toKey(path[index++])]; ++ } ++ ++ return index && index == length ? object : undefined; ++} ++ ++var _baseGet = baseGet; ++ ++/** ++ * Gets the value at `path` of `object`. If the resolved value is ++ * `undefined`, the `defaultValue` is returned in its place. ++ * ++ * @static ++ * @memberOf _ ++ * @since 3.7.0 ++ * @category Object ++ * @param {Object} object The object to query. ++ * @param {Array|string} path The path of the property to get. ++ * @param {*} [defaultValue] The value returned for `undefined` resolved values. ++ * @returns {*} Returns the resolved value. ++ * @example ++ * ++ * var object = { 'a': [{ 'b': { 'c': 3 } }] }; ++ * ++ * _.get(object, 'a[0].b.c'); ++ * // => 3 ++ * ++ * _.get(object, ['a', '0', 'b', 'c']); ++ * // => 3 ++ * ++ * _.get(object, 'a.b.c', 'default'); ++ * // => 'default' ++ */ ++ ++function get$1(object, path, defaultValue) { ++ var result = object == null ? undefined : _baseGet(object, path); ++ return result === undefined ? defaultValue : result; ++} ++ ++var get_1 = get$1; ++ ++/** ++ * The base implementation of `_.hasIn` without support for deep paths. ++ * ++ * @private ++ * @param {Object} [object] The object to query. ++ * @param {Array|string} key The key to check. ++ * @returns {boolean} Returns `true` if `key` exists, else `false`. ++ */ ++function baseHasIn(object, key) { ++ return object != null && key in Object(object); ++} ++ ++var _baseHasIn = baseHasIn; ++ ++/** ++ * Checks if `path` exists on `object`. ++ * ++ * @private ++ * @param {Object} object The object to query. ++ * @param {Array|string} path The path to check. ++ * @param {Function} hasFunc The function to check properties. ++ * @returns {boolean} Returns `true` if `path` exists, else `false`. ++ */ ++ ++function hasPath(object, path, hasFunc) { ++ path = _castPath(path, object); ++ var index = -1, ++ length = path.length, ++ result = false; ++ ++ while (++index < length) { ++ var key = _toKey(path[index]); ++ ++ if (!(result = object != null && hasFunc(object, key))) { ++ break; ++ } ++ ++ object = object[key]; ++ } ++ ++ if (result || ++index != length) { ++ return result; ++ } ++ ++ length = object == null ? 0 : object.length; ++ return !!length && isLength_1(length) && _isIndex(key, length) && (isArray_1(object) || isArguments_1(object)); ++} ++ ++var _hasPath = hasPath; ++ ++/** ++ * Checks if `path` is a direct or inherited property of `object`. ++ * ++ * @static ++ * @memberOf _ ++ * @since 4.0.0 ++ * @category Object ++ * @param {Object} object The object to query. ++ * @param {Array|string} path The path to check. ++ * @returns {boolean} Returns `true` if `path` exists, else `false`. ++ * @example ++ * ++ * var object = _.create({ 'a': _.create({ 'b': 2 }) }); ++ * ++ * _.hasIn(object, 'a'); ++ * // => true ++ * ++ * _.hasIn(object, 'a.b'); ++ * // => true ++ * ++ * _.hasIn(object, ['a', 'b']); ++ * // => true ++ * ++ * _.hasIn(object, 'b'); ++ * // => false ++ */ ++ ++function hasIn(object, path) { ++ return object != null && _hasPath(object, path, _baseHasIn); ++} ++ ++var hasIn_1 = hasIn; ++ ++/** Used to compose bitmasks for value comparisons. */ ++ ++var COMPARE_PARTIAL_FLAG$5 = 1, ++ COMPARE_UNORDERED_FLAG$3 = 2; ++/** ++ * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`. ++ * ++ * @private ++ * @param {string} path The path of the property to get. ++ * @param {*} srcValue The value to match. ++ * @returns {Function} Returns the new spec function. ++ */ ++ ++function baseMatchesProperty(path, srcValue) { ++ if (_isKey(path) && _isStrictComparable(srcValue)) { ++ return _matchesStrictComparable(_toKey(path), srcValue); ++ } ++ ++ return function (object) { ++ var objValue = get_1(object, path); ++ return objValue === undefined && objValue === srcValue ? hasIn_1(object, path) : _baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG$5 | COMPARE_UNORDERED_FLAG$3); ++ }; ++} ++ ++var _baseMatchesProperty = baseMatchesProperty; ++ ++/** ++ * This method returns the first argument it receives. ++ * ++ * @static ++ * @since 0.1.0 ++ * @memberOf _ ++ * @category Util ++ * @param {*} value Any value. ++ * @returns {*} Returns `value`. ++ * @example ++ * ++ * var object = { 'a': 1 }; ++ * ++ * console.log(_.identity(object) === object); ++ * // => true ++ */ ++function identity(value) { ++ return value; ++} ++ ++var identity_1 = identity; ++ ++/** ++ * The base implementation of `_.property` without support for deep paths. ++ * ++ * @private ++ * @param {string} key The key of the property to get. ++ * @returns {Function} Returns the new accessor function. ++ */ ++function baseProperty(key) { ++ return function (object) { ++ return object == null ? undefined : object[key]; ++ }; ++} ++ ++var _baseProperty = baseProperty; ++ ++/** ++ * A specialized version of `baseProperty` which supports deep paths. ++ * ++ * @private ++ * @param {Array|string} path The path of the property to get. ++ * @returns {Function} Returns the new accessor function. ++ */ ++ ++function basePropertyDeep(path) { ++ return function (object) { ++ return _baseGet(object, path); ++ }; ++} ++ ++var _basePropertyDeep = basePropertyDeep; ++ ++/** ++ * Creates a function that returns the value at `path` of a given object. ++ * ++ * @static ++ * @memberOf _ ++ * @since 2.4.0 ++ * @category Util ++ * @param {Array|string} path The path of the property to get. ++ * @returns {Function} Returns the new accessor function. ++ * @example ++ * ++ * var objects = [ ++ * { 'a': { 'b': 2 } }, ++ * { 'a': { 'b': 1 } } ++ * ]; ++ * ++ * _.map(objects, _.property('a.b')); ++ * // => [2, 1] ++ * ++ * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b'); ++ * // => [1, 2] ++ */ ++ ++function property(path) { ++ return _isKey(path) ? _baseProperty(_toKey(path)) : _basePropertyDeep(path); ++} ++ ++var property_1 = property; ++ ++/** ++ * The base implementation of `_.iteratee`. ++ * ++ * @private ++ * @param {*} [value=_.identity] The value to convert to an iteratee. ++ * @returns {Function} Returns the iteratee. ++ */ ++ ++function baseIteratee(value) { ++ // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9. ++ // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details. ++ if (typeof value == 'function') { ++ return value; ++ } ++ ++ if (value == null) { ++ return identity_1; ++ } ++ ++ if (typeof value == 'object') { ++ return isArray_1(value) ? _baseMatchesProperty(value[0], value[1]) : _baseMatches(value); ++ } ++ ++ return property_1(value); ++} ++ ++var _baseIteratee = baseIteratee; ++ ++/** ++ * The base implementation of `_.findIndex` and `_.findLastIndex` without ++ * support for iteratee shorthands. ++ * ++ * @private ++ * @param {Array} array The array to inspect. ++ * @param {Function} predicate The function invoked per iteration. ++ * @param {number} fromIndex The index to search from. ++ * @param {boolean} [fromRight] Specify iterating from right to left. ++ * @returns {number} Returns the index of the matched value, else `-1`. ++ */ ++function baseFindIndex(array, predicate, fromIndex, fromRight) { ++ var length = array.length, ++ index = fromIndex + (fromRight ? 1 : -1); ++ ++ while (fromRight ? index-- : ++index < length) { ++ if (predicate(array[index], index, array)) { ++ return index; ++ } ++ } ++ ++ return -1; ++} ++ ++var _baseFindIndex = baseFindIndex; ++ ++/** ++ * The base implementation of `_.isNaN` without support for number objects. ++ * ++ * @private ++ * @param {*} value The value to check. ++ * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`. ++ */ ++function baseIsNaN(value) { ++ return value !== value; ++} ++ ++var _baseIsNaN = baseIsNaN; ++ ++/** ++ * A specialized version of `_.indexOf` which performs strict equality ++ * comparisons of values, i.e. `===`. ++ * ++ * @private ++ * @param {Array} array The array to inspect. ++ * @param {*} value The value to search for. ++ * @param {number} fromIndex The index to search from. ++ * @returns {number} Returns the index of the matched value, else `-1`. ++ */ ++function strictIndexOf(array, value, fromIndex) { ++ var index = fromIndex - 1, ++ length = array.length; ++ ++ while (++index < length) { ++ if (array[index] === value) { ++ return index; ++ } ++ } ++ ++ return -1; ++} ++ ++var _strictIndexOf = strictIndexOf; ++ ++/** ++ * The base implementation of `_.indexOf` without `fromIndex` bounds checks. ++ * ++ * @private ++ * @param {Array} array The array to inspect. ++ * @param {*} value The value to search for. ++ * @param {number} fromIndex The index to search from. ++ * @returns {number} Returns the index of the matched value, else `-1`. ++ */ ++ ++function baseIndexOf(array, value, fromIndex) { ++ return value === value ? _strictIndexOf(array, value, fromIndex) : _baseFindIndex(array, _baseIsNaN, fromIndex); ++} ++ ++var _baseIndexOf = baseIndexOf; ++ ++/** ++ * A specialized version of `_.includes` for arrays without support for ++ * specifying an index to search from. ++ * ++ * @private ++ * @param {Array} [array] The array to inspect. ++ * @param {*} target The value to search for. ++ * @returns {boolean} Returns `true` if `target` is found, else `false`. ++ */ ++ ++function arrayIncludes(array, value) { ++ var length = array == null ? 0 : array.length; ++ return !!length && _baseIndexOf(array, value, 0) > -1; ++} ++ ++var _arrayIncludes = arrayIncludes; ++ ++/** ++ * This function is like `arrayIncludes` except that it accepts a comparator. ++ * ++ * @private ++ * @param {Array} [array] The array to inspect. ++ * @param {*} target The value to search for. ++ * @param {Function} comparator The comparator invoked per element. ++ * @returns {boolean} Returns `true` if `target` is found, else `false`. ++ */ ++function arrayIncludesWith(array, value, comparator) { ++ var index = -1, ++ length = array == null ? 0 : array.length; ++ ++ while (++index < length) { ++ if (comparator(value, array[index])) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++ ++var _arrayIncludesWith = arrayIncludesWith; ++ ++/** ++ * This method returns `undefined`. ++ * ++ * @static ++ * @memberOf _ ++ * @since 2.3.0 ++ * @category Util ++ * @example ++ * ++ * _.times(2, _.noop); ++ * // => [undefined, undefined] ++ */ ++function noop() {// No operation performed. ++} ++ ++var noop_1 = noop; ++ ++/** Used as references for various `Number` constants. */ ++ ++var INFINITY$2 = 1 / 0; ++/** ++ * Creates a set object of `values`. ++ * ++ * @private ++ * @param {Array} values The values to add to the set. ++ * @returns {Object} Returns the new set. ++ */ ++ ++var createSet = !(_Set && 1 / _setToArray(new _Set([, -0]))[1] == INFINITY$2) ? noop_1 : function (values) { ++ return new _Set(values); ++}; ++var _createSet = createSet; ++ ++/** Used as the size to enable large array optimizations. */ ++ ++var LARGE_ARRAY_SIZE$1 = 200; ++/** ++ * The base implementation of `_.uniqBy` without support for iteratee shorthands. ++ * ++ * @private ++ * @param {Array} array The array to inspect. ++ * @param {Function} [iteratee] The iteratee invoked per element. ++ * @param {Function} [comparator] The comparator invoked per element. ++ * @returns {Array} Returns the new duplicate free array. ++ */ ++ ++function baseUniq(array, iteratee, comparator) { ++ var index = -1, ++ includes = _arrayIncludes, ++ length = array.length, ++ isCommon = true, ++ result = [], ++ seen = result; ++ ++ if (comparator) { ++ isCommon = false; ++ includes = _arrayIncludesWith; ++ } else if (length >= LARGE_ARRAY_SIZE$1) { ++ var set = iteratee ? null : _createSet(array); ++ ++ if (set) { ++ return _setToArray(set); ++ } ++ ++ isCommon = false; ++ includes = _cacheHas; ++ seen = new _SetCache(); ++ } else { ++ seen = iteratee ? [] : result; ++ } ++ ++ outer: while (++index < length) { ++ var value = array[index], ++ computed = iteratee ? iteratee(value) : value; ++ value = comparator || value !== 0 ? value : 0; ++ ++ if (isCommon && computed === computed) { ++ var seenIndex = seen.length; ++ ++ while (seenIndex--) { ++ if (seen[seenIndex] === computed) { ++ continue outer; ++ } ++ } ++ ++ if (iteratee) { ++ seen.push(computed); ++ } ++ ++ result.push(value); ++ } else if (!includes(seen, computed, comparator)) { ++ if (seen !== result) { ++ seen.push(computed); ++ } ++ ++ result.push(value); ++ } ++ } ++ ++ return result; ++} ++ ++var _baseUniq = baseUniq; ++ ++/** ++ * This method is like `_.uniq` except that it accepts `iteratee` which is ++ * invoked for each element in `array` to generate the criterion by which ++ * uniqueness is computed. The order of result values is determined by the ++ * order they occur in the array. The iteratee is invoked with one argument: ++ * (value). ++ * ++ * @static ++ * @memberOf _ ++ * @since 4.0.0 ++ * @category Array ++ * @param {Array} array The array to inspect. ++ * @param {Function} [iteratee=_.identity] The iteratee invoked per element. ++ * @returns {Array} Returns the new duplicate free array. ++ * @example ++ * ++ * _.uniqBy([2.1, 1.2, 2.3], Math.floor); ++ * // => [2.1, 1.2] ++ * ++ * // The `_.property` iteratee shorthand. ++ * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x'); ++ * // => [{ 'x': 1 }, { 'x': 2 }] ++ */ ++ ++function uniqBy(array, iteratee) { ++ return array && array.length ? _baseUniq(array, _baseIteratee(iteratee)) : []; ++} ++ ++var uniqBy_1 = uniqBy; ++ ++/** ++ * A specialized version of `baseAggregator` for arrays. ++ * ++ * @private ++ * @param {Array} [array] The array to iterate over. ++ * @param {Function} setter The function to set `accumulator` values. ++ * @param {Function} iteratee The iteratee to transform keys. ++ * @param {Object} accumulator The initial aggregated object. ++ * @returns {Function} Returns `accumulator`. ++ */ ++function arrayAggregator(array, setter, iteratee, accumulator) { ++ var index = -1, ++ length = array == null ? 0 : array.length; ++ ++ while (++index < length) { ++ var value = array[index]; ++ setter(accumulator, value, iteratee(value), array); ++ } ++ ++ return accumulator; ++} ++ ++var _arrayAggregator = arrayAggregator; ++ ++/** ++ * Creates a base function for methods like `_.forIn` and `_.forOwn`. ++ * ++ * @private ++ * @param {boolean} [fromRight] Specify iterating from right to left. ++ * @returns {Function} Returns the new base function. ++ */ ++function createBaseFor(fromRight) { ++ return function (object, iteratee, keysFunc) { ++ var index = -1, ++ iterable = Object(object), ++ props = keysFunc(object), ++ length = props.length; ++ ++ while (length--) { ++ var key = props[fromRight ? length : ++index]; ++ ++ if (iteratee(iterable[key], key, iterable) === false) { ++ break; ++ } ++ } ++ ++ return object; ++ }; ++} ++ ++var _createBaseFor = createBaseFor; ++ ++/** ++ * The base implementation of `baseForOwn` which iterates over `object` ++ * properties returned by `keysFunc` and invokes `iteratee` for each property. ++ * Iteratee functions may exit iteration early by explicitly returning `false`. ++ * ++ * @private ++ * @param {Object} object The object to iterate over. ++ * @param {Function} iteratee The function invoked per iteration. ++ * @param {Function} keysFunc The function to get the keys of `object`. ++ * @returns {Object} Returns `object`. ++ */ ++ ++var baseFor = _createBaseFor(); ++var _baseFor = baseFor; ++ ++/** ++ * The base implementation of `_.forOwn` without support for iteratee shorthands. ++ * ++ * @private ++ * @param {Object} object The object to iterate over. ++ * @param {Function} iteratee The function invoked per iteration. ++ * @returns {Object} Returns `object`. ++ */ ++ ++function baseForOwn(object, iteratee) { ++ return object && _baseFor(object, iteratee, keys_1); ++} ++ ++var _baseForOwn = baseForOwn; ++ ++/** ++ * Creates a `baseEach` or `baseEachRight` function. ++ * ++ * @private ++ * @param {Function} eachFunc The function to iterate over a collection. ++ * @param {boolean} [fromRight] Specify iterating from right to left. ++ * @returns {Function} Returns the new base function. ++ */ ++ ++function createBaseEach(eachFunc, fromRight) { ++ return function (collection, iteratee) { ++ if (collection == null) { ++ return collection; ++ } ++ ++ if (!isArrayLike_1(collection)) { ++ return eachFunc(collection, iteratee); ++ } ++ ++ var length = collection.length, ++ index = fromRight ? length : -1, ++ iterable = Object(collection); ++ ++ while (fromRight ? index-- : ++index < length) { ++ if (iteratee(iterable[index], index, iterable) === false) { ++ break; ++ } ++ } ++ ++ return collection; ++ }; ++} ++ ++var _createBaseEach = createBaseEach; ++ ++/** ++ * The base implementation of `_.forEach` without support for iteratee shorthands. ++ * ++ * @private ++ * @param {Array|Object} collection The collection to iterate over. ++ * @param {Function} iteratee The function invoked per iteration. ++ * @returns {Array|Object} Returns `collection`. ++ */ ++ ++var baseEach = _createBaseEach(_baseForOwn); ++var _baseEach = baseEach; ++ ++/** ++ * Aggregates elements of `collection` on `accumulator` with keys transformed ++ * by `iteratee` and values set by `setter`. ++ * ++ * @private ++ * @param {Array|Object} collection The collection to iterate over. ++ * @param {Function} setter The function to set `accumulator` values. ++ * @param {Function} iteratee The iteratee to transform keys. ++ * @param {Object} accumulator The initial aggregated object. ++ * @returns {Function} Returns `accumulator`. ++ */ ++ ++function baseAggregator(collection, setter, iteratee, accumulator) { ++ _baseEach(collection, function (value, key, collection) { ++ setter(accumulator, value, iteratee(value), collection); ++ }); ++ return accumulator; ++} ++ ++var _baseAggregator = baseAggregator; ++ ++/** ++ * Creates a function like `_.groupBy`. ++ * ++ * @private ++ * @param {Function} setter The function to set accumulator values. ++ * @param {Function} [initializer] The accumulator object initializer. ++ * @returns {Function} Returns the new aggregator function. ++ */ ++ ++function createAggregator(setter, initializer) { ++ return function (collection, iteratee) { ++ var func = isArray_1(collection) ? _arrayAggregator : _baseAggregator, ++ accumulator = initializer ? initializer() : {}; ++ return func(collection, setter, _baseIteratee(iteratee), accumulator); ++ }; ++} ++ ++var _createAggregator = createAggregator; ++ ++/** ++ * Creates an array of elements split into two groups, the first of which ++ * contains elements `predicate` returns truthy for, the second of which ++ * contains elements `predicate` returns falsey for. The predicate is ++ * invoked with one argument: (value). ++ * ++ * @static ++ * @memberOf _ ++ * @since 3.0.0 ++ * @category Collection ++ * @param {Array|Object} collection The collection to iterate over. ++ * @param {Function} [predicate=_.identity] The function invoked per iteration. ++ * @returns {Array} Returns the array of grouped elements. ++ * @example ++ * ++ * var users = [ ++ * { 'user': 'barney', 'age': 36, 'active': false }, ++ * { 'user': 'fred', 'age': 40, 'active': true }, ++ * { 'user': 'pebbles', 'age': 1, 'active': false } ++ * ]; ++ * ++ * _.partition(users, function(o) { return o.active; }); ++ * // => objects for [['fred'], ['barney', 'pebbles']] ++ * ++ * // The `_.matches` iteratee shorthand. ++ * _.partition(users, { 'age': 1, 'active': false }); ++ * // => objects for [['pebbles'], ['barney', 'fred']] ++ * ++ * // The `_.matchesProperty` iteratee shorthand. ++ * _.partition(users, ['active', false]); ++ * // => objects for [['barney', 'pebbles'], ['fred']] ++ * ++ * // The `_.property` iteratee shorthand. ++ * _.partition(users, 'active'); ++ * // => objects for [['fred'], ['barney', 'pebbles']] ++ */ ++ ++var partition = _createAggregator(function (result, value, key) { ++ result[key ? 0 : 1].push(value); ++}, function () { ++ return [[], []]; ++}); ++var partition_1 = partition; ++ ++var arrayUnion = (...arguments_) => { ++ return [...new Set([].concat(...arguments_))]; ++}; ++ ++/* ++ * merge2 ++ * https://github.com/teambition/merge2 ++ * ++ * Copyright (c) 2014-2016 Teambition ++ * Licensed under the MIT license. ++ */ ++ ++ ++const PassThrough = stream$5.PassThrough; ++const slice = Array.prototype.slice; ++var merge2_1 = merge2; ++ ++function merge2() { ++ const streamsQueue = []; ++ let merging = false; ++ const args = slice.call(arguments); ++ let options = args[args.length - 1]; ++ if (options && !Array.isArray(options) && options.pipe == null) args.pop();else options = {}; ++ const doEnd = options.end !== false; ++ if (options.objectMode == null) options.objectMode = true; ++ if (options.highWaterMark == null) options.highWaterMark = 64 * 1024; ++ const mergedStream = PassThrough(options); ++ ++ function addStream() { ++ for (let i = 0, len = arguments.length; i < len; i++) { ++ streamsQueue.push(pauseStreams(arguments[i], options)); ++ } ++ ++ mergeStream(); ++ return this; ++ } ++ ++ function mergeStream() { ++ if (merging) return; ++ merging = true; ++ let streams = streamsQueue.shift(); ++ ++ if (!streams) { ++ process.nextTick(endStream); ++ return; ++ } ++ ++ if (!Array.isArray(streams)) streams = [streams]; ++ let pipesCount = streams.length + 1; ++ ++ function next() { ++ if (--pipesCount > 0) return; ++ merging = false; ++ mergeStream(); ++ } ++ ++ function pipe(stream) { ++ function onend() { ++ stream.removeListener('merge2UnpipeEnd', onend); ++ stream.removeListener('end', onend); ++ next(); ++ } // skip ended stream ++ ++ ++ if (stream._readableState.endEmitted) return next(); ++ stream.on('merge2UnpipeEnd', onend); ++ stream.on('end', onend); ++ stream.pipe(mergedStream, { ++ end: false ++ }); // compatible for old stream ++ ++ stream.resume(); ++ } ++ ++ for (let i = 0; i < streams.length; i++) pipe(streams[i]); ++ ++ next(); ++ } ++ ++ function endStream() { ++ merging = false; // emit 'queueDrain' when all streams merged. ++ ++ mergedStream.emit('queueDrain'); ++ return doEnd && mergedStream.end(); ++ } ++ ++ mergedStream.setMaxListeners(0); ++ mergedStream.add = addStream; ++ mergedStream.on('unpipe', function (stream) { ++ stream.emit('merge2UnpipeEnd'); ++ }); ++ if (args.length) addStream.apply(null, args); ++ return mergedStream; ++} // check and pause streams for pipe. ++ ++ ++function pauseStreams(streams, options) { ++ if (!Array.isArray(streams)) { ++ // Backwards-compat with old-style streams ++ if (!streams._readableState && streams.pipe) streams = streams.pipe(PassThrough(options)); ++ ++ if (!streams._readableState || !streams.pause || !streams.pipe) { ++ throw new Error('Only readable stream can be merged.'); ++ } ++ ++ streams.pause(); ++ } else { ++ for (let i = 0, len = streams.length; i < len; i++) streams[i] = pauseStreams(streams[i], options); ++ } ++ ++ return streams; ++} ++ ++var array$2 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ function flatten(items) { ++ return items.reduce((collection, item) => [].concat(collection, item), []); ++ } ++ ++ exports.flatten = flatten; ++ ++ function splitWhen(items, predicate) { ++ const result = [[]]; ++ let groupIndex = 0; ++ ++ for (const item of items) { ++ if (predicate(item)) { ++ groupIndex++; ++ result[groupIndex] = []; ++ } else { ++ result[groupIndex].push(item); ++ } ++ } ++ ++ return result; ++ } ++ ++ exports.splitWhen = splitWhen; ++}); ++unwrapExports(array$2); ++var array_1$1 = array$2.flatten; ++var array_2 = array$2.splitWhen; ++ ++var errno = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ function isEnoentCodeError(error) { ++ return error.code === 'ENOENT'; ++ } ++ ++ exports.isEnoentCodeError = isEnoentCodeError; ++}); ++unwrapExports(errno); ++var errno_1 = errno.isEnoentCodeError; ++ ++var fs = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class DirentFromStats { ++ constructor(name, stats) { ++ this.name = name; ++ this.isBlockDevice = stats.isBlockDevice.bind(stats); ++ this.isCharacterDevice = stats.isCharacterDevice.bind(stats); ++ this.isDirectory = stats.isDirectory.bind(stats); ++ this.isFIFO = stats.isFIFO.bind(stats); ++ this.isFile = stats.isFile.bind(stats); ++ this.isSocket = stats.isSocket.bind(stats); ++ this.isSymbolicLink = stats.isSymbolicLink.bind(stats); ++ } ++ ++ } ++ ++ function createDirentFromStats(name, stats) { ++ return new DirentFromStats(name, stats); ++ } ++ ++ exports.createDirentFromStats = createDirentFromStats; ++}); ++unwrapExports(fs); ++var fs_1 = fs.createDirentFromStats; ++ ++var path_1 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ const LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2; // ./ or .\\ ++ ++ const UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\())/g; ++ /** ++ * Designed to work only with simple paths: `dir\\file`. ++ */ ++ ++ function unixify(filepath) { ++ return filepath.replace(/\\/g, '/'); ++ } ++ ++ exports.unixify = unixify; ++ ++ function makeAbsolute(cwd, filepath) { ++ return path$1.resolve(cwd, filepath); ++ } ++ ++ exports.makeAbsolute = makeAbsolute; ++ ++ function escape(pattern) { ++ return pattern.replace(UNESCAPED_GLOB_SYMBOLS_RE, '\\$2'); ++ } ++ ++ exports.escape = escape; ++ ++ function removeLeadingDotSegment(entry) { ++ // We do not use `startsWith` because this is 10x slower than current implementation for some cases. ++ // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with ++ if (entry.charAt(0) === '.') { ++ const secondCharactery = entry.charAt(1); ++ ++ if (secondCharactery === '/' || secondCharactery === '\\') { ++ return entry.slice(LEADING_DOT_SEGMENT_CHARACTERS_COUNT); ++ } ++ } ++ ++ return entry; ++ } ++ ++ exports.removeLeadingDotSegment = removeLeadingDotSegment; ++}); ++unwrapExports(path_1); ++var path_2 = path_1.unixify; ++var path_3 = path_1.makeAbsolute; ++var path_4 = path_1.escape; ++var path_5 = path_1.removeLeadingDotSegment; ++ ++/*! ++ * is-extglob ++ * ++ * Copyright (c) 2014-2016, Jon Schlinkert. ++ * Licensed under the MIT License. ++ */ ++var isExtglob = function isExtglob(str) { ++ if (typeof str !== 'string' || str === '') { ++ return false; ++ } ++ ++ var match; ++ ++ while (match = /(\\).|([@?!+*]\(.*\))/g.exec(str)) { ++ if (match[2]) return true; ++ str = str.slice(match.index + match[0].length); ++ } ++ ++ return false; ++}; ++ ++/*! ++ * is-glob ++ * ++ * Copyright (c) 2014-2017, Jon Schlinkert. ++ * Released under the MIT License. ++ */ ++ ++var chars = { ++ '{': '}', ++ '(': ')', ++ '[': ']' ++}; ++var strictRegex = /\\(.)|(^!|\*|[\].+)]\?|\[[^\\\]]+\]|\{[^\\}]+\}|\(\?[:!=][^\\)]+\)|\([^|]+\|[^\\)]+\))/; ++var relaxedRegex = /\\(.)|(^!|[*?{}()[\]]|\(\?)/; ++ ++var isGlob = function isGlob(str, options) { ++ if (typeof str !== 'string' || str === '') { ++ return false; ++ } ++ ++ if (isExtglob(str)) { ++ return true; ++ } ++ ++ var regex = strictRegex; ++ var match; // optionally relax regex ++ ++ if (options && options.strict === false) { ++ regex = relaxedRegex; ++ } ++ ++ while (match = regex.exec(str)) { ++ if (match[2]) return true; ++ var idx = match.index + match[0].length; // if an open bracket/brace/paren is escaped, ++ // set the index to the next closing character ++ ++ var open = match[1]; ++ var close = open ? chars[open] : null; ++ ++ if (open && close) { ++ var n = str.indexOf(close, idx); ++ ++ if (n !== -1) { ++ idx = n + 1; ++ } ++ } ++ ++ str = str.slice(idx); ++ } ++ ++ return false; ++}; ++ ++var pathPosixDirname = path$1.posix.dirname; ++var isWin32 = os.platform() === 'win32'; ++var slash = '/'; ++var backslash = /\\/g; ++var enclosure = /[\{\[].*[\/]*.*[\}\]]$/; ++var globby = /(^|[^\\])([\{\[]|\([^\)]+$)/; ++var escaped = /\\([\*\?\|\[\]\(\)\{\}])/g; ++/** ++ * @param {string} str ++ * @param {Object} opts ++ * @param {boolean} [opts.flipBackslashes=true] ++ */ ++ ++var globParent = 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 (enclosure.test(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 (isGlob(str) || globby.test(str)); // remove escape chars and return result ++ ++ ++ return str.replace(escaped, '$1'); ++}; ++ ++var utils$2 = createCommonjsModule(function (module, exports) { ++ ++ exports.isInteger = num => { ++ if (typeof num === 'number') { ++ return Number.isInteger(num); ++ } ++ ++ if (typeof num === 'string' && num.trim() !== '') { ++ return Number.isInteger(Number(num)); ++ } ++ ++ return false; ++ }; ++ /** ++ * Find a node of the given type ++ */ ++ ++ ++ exports.find = (node, type) => node.nodes.find(node => node.type === type); ++ /** ++ * Find a node of the given type ++ */ ++ ++ ++ exports.exceedsLimit = (min, max, step = 1, limit) => { ++ if (limit === false) return false; ++ if (!exports.isInteger(min) || !exports.isInteger(max)) return false; ++ return (Number(max) - Number(min)) / Number(step) >= limit; ++ }; ++ /** ++ * Escape the given node with '\\' before node.value ++ */ ++ ++ ++ exports.escapeNode = (block, n = 0, type) => { ++ let node = block.nodes[n]; ++ if (!node) return; ++ ++ if (type && node.type === type || node.type === 'open' || node.type === 'close') { ++ if (node.escaped !== true) { ++ node.value = '\\' + node.value; ++ node.escaped = true; ++ } ++ } ++ }; ++ /** ++ * Returns true if the given brace node should be enclosed in literal braces ++ */ ++ ++ ++ exports.encloseBrace = node => { ++ if (node.type !== 'brace') return false; ++ ++ if (node.commas >> 0 + node.ranges >> 0 === 0) { ++ node.invalid = true; ++ return true; ++ } ++ ++ return false; ++ }; ++ /** ++ * Returns true if a brace node is invalid. ++ */ ++ ++ ++ exports.isInvalidBrace = block => { ++ if (block.type !== 'brace') return false; ++ if (block.invalid === true || block.dollar) return true; ++ ++ if (block.commas >> 0 + block.ranges >> 0 === 0) { ++ block.invalid = true; ++ return true; ++ } ++ ++ if (block.open !== true || block.close !== true) { ++ block.invalid = true; ++ return true; ++ } ++ ++ return false; ++ }; ++ /** ++ * Returns true if a node is an open or close node ++ */ ++ ++ ++ exports.isOpenOrClose = node => { ++ if (node.type === 'open' || node.type === 'close') { ++ return true; ++ } ++ ++ return node.open === true || node.close === true; ++ }; ++ /** ++ * Reduce an array of text nodes. ++ */ ++ ++ ++ exports.reduce = nodes => nodes.reduce((acc, node) => { ++ if (node.type === 'text') acc.push(node.value); ++ if (node.type === 'range') node.type = 'text'; ++ return acc; ++ }, []); ++ /** ++ * Flatten an array ++ */ ++ ++ ++ exports.flatten = (...args) => { ++ const result = []; ++ ++ const flat = arr => { ++ for (let i = 0; i < arr.length; i++) { ++ let ele = arr[i]; ++ Array.isArray(ele) ? flat(ele) : ele !== void 0 && result.push(ele); ++ } ++ ++ return result; ++ }; ++ ++ flat(args); ++ return result; ++ }; ++}); ++var utils_1$2 = utils$2.isInteger; ++var utils_2$2 = utils$2.find; ++var utils_3$2 = utils$2.exceedsLimit; ++var utils_4$1 = utils$2.escapeNode; ++var utils_5$1 = utils$2.encloseBrace; ++var utils_6$1 = utils$2.isInvalidBrace; ++var utils_7$1 = utils$2.isOpenOrClose; ++var utils_8$1 = utils$2.reduce; ++var utils_9$1 = utils$2.flatten; ++ ++var stringify = (ast, options = {}) => { ++ let stringify = (node, parent = {}) => { ++ let invalidBlock = options.escapeInvalid && utils$2.isInvalidBrace(parent); ++ let invalidNode = node.invalid === true && options.escapeInvalid === true; ++ let output = ''; ++ ++ if (node.value) { ++ if ((invalidBlock || invalidNode) && utils$2.isOpenOrClose(node)) { ++ return '\\' + node.value; ++ } ++ ++ return node.value; ++ } ++ ++ if (node.value) { ++ return node.value; ++ } ++ ++ if (node.nodes) { ++ for (let child of node.nodes) { ++ output += stringify(child); ++ } ++ } ++ ++ return output; ++ }; ++ ++ return stringify(ast); ++}; ++ ++/*! ++ * is-number ++ * ++ * Copyright (c) 2014-present, Jon Schlinkert. ++ * Released under the MIT License. ++ */ ++ ++var isNumber = function (num) { ++ if (typeof num === 'number') { ++ return num - num === 0; ++ } ++ ++ if (typeof num === 'string' && num.trim() !== '') { ++ return Number.isFinite ? Number.isFinite(+num) : isFinite(+num); ++ } ++ ++ return false; ++}; ++ ++const toRegexRange = (min, max, options) => { ++ if (isNumber(min) === false) { ++ throw new TypeError('toRegexRange: expected the first argument to be a number'); ++ } ++ ++ if (max === void 0 || min === max) { ++ return String(min); ++ } ++ ++ if (isNumber(max) === false) { ++ throw new TypeError('toRegexRange: expected the second argument to be a number.'); ++ } ++ ++ let opts = Object.assign({ ++ relaxZeros: true ++ }, options); ++ ++ if (typeof opts.strictZeros === 'boolean') { ++ opts.relaxZeros = opts.strictZeros === false; ++ } ++ ++ let relax = String(opts.relaxZeros); ++ let shorthand = String(opts.shorthand); ++ let capture = String(opts.capture); ++ let wrap = String(opts.wrap); ++ let cacheKey = min + ':' + max + '=' + relax + shorthand + capture + wrap; ++ ++ if (toRegexRange.cache.hasOwnProperty(cacheKey)) { ++ return toRegexRange.cache[cacheKey].result; ++ } ++ ++ let a = Math.min(min, max); ++ let b = Math.max(min, max); ++ ++ if (Math.abs(a - b) === 1) { ++ let result = min + '|' + max; ++ ++ if (opts.capture) { ++ return `(${result})`; ++ } ++ ++ if (opts.wrap === false) { ++ return result; ++ } ++ ++ return `(?:${result})`; ++ } ++ ++ let isPadded = hasPadding(min) || hasPadding(max); ++ let state = { ++ min, ++ max, ++ a, ++ b ++ }; ++ let positives = []; ++ let negatives = []; ++ ++ if (isPadded) { ++ state.isPadded = isPadded; ++ state.maxLen = String(state.max).length; ++ } ++ ++ if (a < 0) { ++ let newMin = b < 0 ? Math.abs(b) : 1; ++ negatives = splitToPatterns(newMin, Math.abs(a), state, opts); ++ a = state.a = 0; ++ } ++ ++ if (b >= 0) { ++ positives = splitToPatterns(a, b, state, opts); ++ } ++ ++ state.negatives = negatives; ++ state.positives = positives; ++ state.result = collatePatterns(negatives, positives); ++ ++ if (opts.capture === true) { ++ state.result = `(${state.result})`; ++ } else if (opts.wrap !== false && positives.length + negatives.length > 1) { ++ state.result = `(?:${state.result})`; ++ } ++ ++ toRegexRange.cache[cacheKey] = state; ++ return state.result; ++}; ++ ++function collatePatterns(neg, pos, options) { ++ let onlyNegative = filterPatterns(neg, pos, '-', false) || []; ++ let onlyPositive = filterPatterns(pos, neg, '', false) || []; ++ let intersected = filterPatterns(neg, pos, '-?', true) || []; ++ let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive); ++ return subpatterns.join('|'); ++} ++ ++function splitToRanges(min, max) { ++ let nines = 1; ++ let zeros = 1; ++ let stop = countNines(min, nines); ++ let stops = new Set([max]); ++ ++ while (min <= stop && stop <= max) { ++ stops.add(stop); ++ nines += 1; ++ stop = countNines(min, nines); ++ } ++ ++ stop = countZeros(max + 1, zeros) - 1; ++ ++ while (min < stop && stop <= max) { ++ stops.add(stop); ++ zeros += 1; ++ stop = countZeros(max + 1, zeros) - 1; ++ } ++ ++ stops = [...stops]; ++ stops.sort(compare$1); ++ return stops; ++} ++/** ++ * Convert a range to a regex pattern ++ * @param {Number} `start` ++ * @param {Number} `stop` ++ * @return {String} ++ */ ++ ++ ++function rangeToPattern(start, stop, options) { ++ if (start === stop) { ++ return { ++ pattern: start, ++ count: [], ++ digits: 0 ++ }; ++ } ++ ++ let zipped = zip(start, stop); ++ let digits = zipped.length; ++ let pattern = ''; ++ let count = 0; ++ ++ for (let i = 0; i < digits; i++) { ++ let [startDigit, stopDigit] = zipped[i]; ++ ++ if (startDigit === stopDigit) { ++ pattern += startDigit; ++ } else if (startDigit !== '0' || stopDigit !== '9') { ++ pattern += toCharacterClass(startDigit, stopDigit); ++ } else { ++ count++; ++ } ++ } ++ ++ if (count) { ++ pattern += options.shorthand === true ? '\\d' : '[0-9]'; ++ } ++ ++ return { ++ pattern, ++ count: [count], ++ digits ++ }; ++} ++ ++function splitToPatterns(min, max, tok, options) { ++ let ranges = splitToRanges(min, max); ++ let tokens = []; ++ let start = min; ++ let prev; ++ ++ for (let i = 0; i < ranges.length; i++) { ++ let max = ranges[i]; ++ let obj = rangeToPattern(String(start), String(max), options); ++ let zeros = ''; ++ ++ if (!tok.isPadded && prev && prev.pattern === obj.pattern) { ++ if (prev.count.length > 1) { ++ prev.count.pop(); ++ } ++ ++ prev.count.push(obj.count[0]); ++ prev.string = prev.pattern + toQuantifier(prev.count); ++ start = max + 1; ++ continue; ++ } ++ ++ if (tok.isPadded) { ++ zeros = padZeros(max, tok, options); ++ } ++ ++ obj.string = zeros + obj.pattern + toQuantifier(obj.count); ++ tokens.push(obj); ++ start = max + 1; ++ prev = obj; ++ } ++ ++ return tokens; ++} ++ ++function filterPatterns(arr, comparison, prefix, intersection, options) { ++ let result = []; ++ ++ for (let ele of arr) { ++ let { ++ string ++ } = ele; // only push if _both_ are negative... ++ ++ if (!intersection && !contains(comparison, 'string', string)) { ++ result.push(prefix + string); ++ } // or _both_ are positive ++ ++ ++ if (intersection && contains(comparison, 'string', string)) { ++ result.push(prefix + string); ++ } ++ } ++ ++ return result; ++} ++/** ++ * Zip strings ++ */ ++ ++ ++function zip(a, b) { ++ let arr = []; ++ ++ for (let i = 0; i < a.length; i++) arr.push([a[i], b[i]]); ++ ++ return arr; ++} ++ ++function compare$1(a, b) { ++ return a > b ? 1 : b > a ? -1 : 0; ++} ++ ++function contains(arr, key, val) { ++ return arr.some(ele => ele[key] === val); ++} ++ ++function countNines(min, len) { ++ return Number(String(min).slice(0, -len) + '9'.repeat(len)); ++} ++ ++function countZeros(integer, zeros) { ++ return integer - integer % Math.pow(10, zeros); ++} ++ ++function toQuantifier(digits) { ++ let [start = 0, stop = ''] = digits; ++ ++ if (stop || start > 1) { ++ return `{${start + (stop ? ',' + stop : '')}}`; ++ } ++ ++ return ''; ++} ++ ++function toCharacterClass(a, b, options) { ++ return `[${a}${b - a === 1 ? '' : '-'}${b}]`; ++} ++ ++function hasPadding(str) { ++ return /^-?(0+)\d/.test(str); ++} ++ ++function padZeros(value, tok, options) { ++ if (!tok.isPadded) { ++ return value; ++ } ++ ++ let diff = Math.abs(tok.maxLen - String(value).length); ++ let relax = options.relaxZeros !== false; ++ ++ switch (diff) { ++ case 0: ++ return ''; ++ ++ case 1: ++ return relax ? '0?' : '0'; ++ ++ case 2: ++ return relax ? '0{0,2}' : '00'; ++ ++ default: ++ { ++ return relax ? `0{0,${diff}}` : `0{${diff}}`; ++ } ++ } ++} ++/** ++ * Cache ++ */ ++ ++ ++toRegexRange.cache = {}; ++ ++toRegexRange.clearCache = () => toRegexRange.cache = {}; ++/** ++ * Expose `toRegexRange` ++ */ ++ ++ ++var toRegexRange_1 = toRegexRange; ++ ++const isObject$1 = val => val !== null && typeof val === 'object' && !Array.isArray(val); ++ ++const transform = toNumber => { ++ return value => toNumber === true ? Number(value) : String(value); ++}; ++ ++const isValidValue = value => { ++ return typeof value === 'number' || typeof value === 'string' && value !== ''; ++}; ++ ++const isNumber$1 = num => Number.isInteger(+num); ++ ++const zeros = input => { ++ let value = `${input}`; ++ let index = -1; ++ if (value[0] === '-') value = value.slice(1); ++ if (value === '0') return false; ++ ++ while (value[++index] === '0'); ++ ++ return index > 0; ++}; ++ ++const stringify$1 = (start, end, options) => { ++ if (typeof start === 'string' || typeof end === 'string') { ++ return true; ++ } ++ ++ return options.stringify === true; ++}; ++ ++const pad = (input, maxLength, toNumber) => { ++ if (maxLength > 0) { ++ let dash = input[0] === '-' ? '-' : ''; ++ if (dash) input = input.slice(1); ++ input = dash + input.padStart(dash ? maxLength - 1 : maxLength, '0'); ++ } ++ ++ if (toNumber === false) { ++ return String(input); ++ } ++ ++ return input; ++}; ++ ++const toMaxLen = (input, maxLength) => { ++ let negative = input[0] === '-' ? '-' : ''; ++ ++ if (negative) { ++ input = input.slice(1); ++ maxLength--; ++ } ++ ++ while (input.length < maxLength) input = '0' + input; ++ ++ return negative ? '-' + input : input; ++}; ++ ++const toSequence = (parts, options) => { ++ parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0); ++ parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0); ++ let prefix = options.capture ? '' : '?:'; ++ let positives = ''; ++ let negatives = ''; ++ let result; ++ ++ if (parts.positives.length) { ++ positives = parts.positives.join('|'); ++ } ++ ++ if (parts.negatives.length) { ++ negatives = `-(${prefix}${parts.negatives.join('|')})`; ++ } ++ ++ if (positives && negatives) { ++ result = `${positives}|${negatives}`; ++ } else { ++ result = positives || negatives; ++ } ++ ++ if (options.wrap) { ++ return `(${prefix}${result})`; ++ } ++ ++ return result; ++}; ++ ++const toRange = (a, b, isNumbers, options) => { ++ if (isNumbers) { ++ return toRegexRange_1(a, b, Object.assign({ ++ wrap: false ++ }, options)); ++ } ++ ++ let start = String.fromCharCode(a); ++ if (a === b) return start; ++ let stop = String.fromCharCode(b); ++ return `[${start}-${stop}]`; ++}; ++ ++const toRegex = (start, end, options) => { ++ if (Array.isArray(start)) { ++ let wrap = options.wrap === true; ++ let prefix = options.capture ? '' : '?:'; ++ return wrap ? `(${prefix}${start.join('|')})` : start.join('|'); ++ } ++ ++ return toRegexRange_1(start, end, options); ++}; ++ ++const rangeError = (...args) => { ++ return new RangeError('Invalid range arguments: ' + util$3.inspect(...args)); ++}; ++ ++const invalidRange = (start, end, options) => { ++ if (options.strictRanges === true) throw rangeError([start, end]); ++ return []; ++}; ++ ++const invalidStep = (step, options) => { ++ if (options.strictRanges === true) { ++ throw new TypeError(`Expected step "${step}" to be a number`); ++ } ++ ++ return []; ++}; ++ ++const fillNumbers = (start, end, step = 1, options = {}) => { ++ let a = Number(start); ++ let b = Number(end); ++ ++ if (!Number.isInteger(a) || !Number.isInteger(b)) { ++ if (options.strictRanges === true) throw rangeError([start, end]); ++ return []; ++ } // fix negative zero ++ ++ ++ if (a === 0) a = 0; ++ if (b === 0) b = 0; ++ let descending = a > b; ++ let startString = String(start); ++ let endString = String(end); ++ let stepString = String(step); ++ step = Math.max(Math.abs(step), 1); ++ let padded = zeros(startString) || zeros(endString) || zeros(stepString); ++ let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0; ++ let toNumber = padded === false && stringify$1(start, end, options) === false; ++ let format = options.transform || transform(toNumber); ++ ++ if (options.toRegex && step === 1) { ++ return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options); ++ } ++ ++ let parts = { ++ negatives: [], ++ positives: [] ++ }; ++ ++ let push = num => parts[num < 0 ? 'negatives' : 'positives'].push(Math.abs(num)); ++ ++ let range = []; ++ let index = 0; ++ ++ while (descending ? a >= b : a <= b) { ++ if (options.toRegex === true && step > 1) { ++ push(a); ++ } else { ++ range.push(pad(format(a, index), maxLen, toNumber)); ++ } ++ ++ a = descending ? a - step : a + step; ++ index++; ++ } ++ ++ if (options.toRegex === true) { ++ return step > 1 ? toSequence(parts, options) : toRegex(range, null, Object.assign({ ++ wrap: false ++ }, options)); ++ } ++ ++ return range; ++}; ++ ++const fillLetters = (start, end, step = 1, options = {}) => { ++ if (!isNumber$1(start) && start.length > 1 || !isNumber$1(end) && end.length > 1) { ++ return invalidRange(start, end, options); ++ } ++ ++ let format = options.transform || (val => String.fromCharCode(val)); ++ ++ let a = `${start}`.charCodeAt(0); ++ let b = `${end}`.charCodeAt(0); ++ let descending = a > b; ++ let min = Math.min(a, b); ++ let max = Math.max(a, b); ++ ++ if (options.toRegex && step === 1) { ++ return toRange(min, max, false, options); ++ } ++ ++ let range = []; ++ let index = 0; ++ ++ while (descending ? a >= b : a <= b) { ++ range.push(format(a, index)); ++ a = descending ? a - step : a + step; ++ index++; ++ } ++ ++ if (options.toRegex === true) { ++ return toRegex(range, null, { ++ wrap: false, ++ options ++ }); ++ } ++ ++ return range; ++}; ++ ++const fill$2 = (start, end, step, options = {}) => { ++ if (end == null && isValidValue(start)) { ++ return [start]; ++ } ++ ++ if (!isValidValue(start) || !isValidValue(end)) { ++ return invalidRange(start, end, options); ++ } ++ ++ if (typeof step === 'function') { ++ return fill$2(start, end, 1, { ++ transform: step ++ }); ++ } ++ ++ if (isObject$1(step)) { ++ return fill$2(start, end, 0, step); ++ } ++ ++ let opts = Object.assign({}, options); ++ if (opts.capture === true) opts.wrap = true; ++ step = step || opts.step || 1; ++ ++ if (!isNumber$1(step)) { ++ if (step != null && !isObject$1(step)) return invalidStep(step, opts); ++ return fill$2(start, end, 1, step); ++ } ++ ++ if (isNumber$1(start) && isNumber$1(end)) { ++ return fillNumbers(start, end, step, opts); ++ } ++ ++ return fillLetters(start, end, Math.max(Math.abs(step), 1), opts); ++}; ++ ++var fillRange = fill$2; ++ ++const compile = (ast, options = {}) => { ++ let walk = (node, parent = {}) => { ++ let invalidBlock = utils$2.isInvalidBrace(parent); ++ let invalidNode = node.invalid === true && options.escapeInvalid === true; ++ let invalid = invalidBlock === true || invalidNode === true; ++ let prefix = options.escapeInvalid === true ? '\\' : ''; ++ let output = ''; ++ ++ if (node.isOpen === true) { ++ return prefix + node.value; ++ } ++ ++ if (node.isClose === true) { ++ return prefix + node.value; ++ } ++ ++ if (node.type === 'open') { ++ return invalid ? prefix + node.value : '('; ++ } ++ ++ if (node.type === 'close') { ++ return invalid ? prefix + node.value : ')'; ++ } ++ ++ if (node.type === 'comma') { ++ return node.prev.type === 'comma' ? '' : invalid ? node.value : '|'; ++ } ++ ++ if (node.value) { ++ return node.value; ++ } ++ ++ if (node.nodes && node.ranges > 0) { ++ let args = utils$2.reduce(node.nodes); ++ let range = fillRange(...args, Object.assign({}, options, { ++ wrap: false, ++ toRegex: true ++ })); ++ ++ if (range.length !== 0) { ++ return args.length > 1 && range.length > 1 ? `(${range})` : range; ++ } ++ } ++ ++ if (node.nodes) { ++ for (let child of node.nodes) { ++ output += walk(child, node); ++ } ++ } ++ ++ return output; ++ }; ++ ++ return walk(ast); ++}; ++ ++var compile_1 = compile; ++ ++const append = (queue = '', stash = '', enclose = false) => { ++ let result = []; ++ queue = [].concat(queue); ++ stash = [].concat(stash); ++ if (!stash.length) return queue; ++ ++ if (!queue.length) { ++ return enclose ? utils$2.flatten(stash).map(ele => `{${ele}}`) : stash; ++ } ++ ++ for (let item of queue) { ++ if (Array.isArray(item)) { ++ for (let value of item) { ++ result.push(append(value, stash, enclose)); ++ } ++ } else { ++ for (let ele of stash) { ++ if (enclose === true && typeof ele === 'string') ele = `{${ele}}`; ++ result.push(Array.isArray(ele) ? append(item, ele, enclose) : item + ele); ++ } ++ } ++ } ++ ++ return utils$2.flatten(result); ++}; ++ ++const expand$1 = (ast, options = {}) => { ++ let rangeLimit = options.rangeLimit === void 0 ? 1000 : options.rangeLimit; ++ ++ let walk = (node, parent = {}) => { ++ node.queue = []; ++ let p = parent; ++ let q = parent.queue; ++ ++ while (p.type !== 'brace' && p.type !== 'root' && p.parent) { ++ p = p.parent; ++ q = p.queue; ++ } ++ ++ if (node.invalid || node.dollar) { ++ q.push(append(q.pop(), stringify(node, options))); ++ return; ++ } ++ ++ if (node.type === 'brace' && node.invalid !== true && node.nodes.length === 2) { ++ q.push(append(q.pop(), ['{}'])); ++ return; ++ } ++ ++ if (node.nodes && node.ranges > 0) { ++ let args = utils$2.reduce(node.nodes); ++ ++ if (utils$2.exceedsLimit(...args, options.step, rangeLimit)) { ++ throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.'); ++ } ++ ++ let range = fillRange(...args, options); ++ ++ if (range.length === 0) { ++ range = stringify(node, options); ++ } ++ ++ q.push(append(q.pop(), range)); ++ node.nodes = []; ++ return; ++ } ++ ++ let enclose = utils$2.encloseBrace(node); ++ let queue = node.queue; ++ let block = node; ++ ++ while (block.type !== 'brace' && block.type !== 'root' && block.parent) { ++ block = block.parent; ++ queue = block.queue; ++ } ++ ++ for (let i = 0; i < node.nodes.length; i++) { ++ let child = node.nodes[i]; ++ ++ if (child.type === 'comma' && node.type === 'brace') { ++ if (i === 1) queue.push(''); ++ queue.push(''); ++ continue; ++ } ++ ++ if (child.type === 'close') { ++ q.push(append(q.pop(), queue, enclose)); ++ continue; ++ } ++ ++ if (child.value && child.type !== 'open') { ++ queue.push(append(queue.pop(), child.value)); ++ continue; ++ } ++ ++ if (child.nodes) { ++ walk(child, node); ++ } ++ } ++ ++ return queue; ++ }; ++ ++ return utils$2.flatten(walk(ast)); ++}; ++ ++var expand_1 = expand$1; ++ ++var constants$1 = { ++ MAX_LENGTH: 1024 * 64, ++ // Digits ++ CHAR_0: '0', ++ ++ /* 0 */ ++ CHAR_9: '9', ++ ++ /* 9 */ ++ // Alphabet chars. ++ CHAR_UPPERCASE_A: 'A', ++ ++ /* A */ ++ CHAR_LOWERCASE_A: 'a', ++ ++ /* a */ ++ CHAR_UPPERCASE_Z: 'Z', ++ ++ /* Z */ ++ CHAR_LOWERCASE_Z: 'z', ++ ++ /* z */ ++ CHAR_LEFT_PARENTHESES: '(', ++ ++ /* ( */ ++ CHAR_RIGHT_PARENTHESES: ')', ++ ++ /* ) */ ++ CHAR_ASTERISK: '*', ++ ++ /* * */ ++ // Non-alphabetic chars. ++ CHAR_AMPERSAND: '&', ++ ++ /* & */ ++ CHAR_AT: '@', ++ ++ /* @ */ ++ CHAR_BACKSLASH: '\\', ++ ++ /* \ */ ++ CHAR_BACKTICK: '`', ++ ++ /* ` */ ++ CHAR_CARRIAGE_RETURN: '\r', ++ ++ /* \r */ ++ CHAR_CIRCUMFLEX_ACCENT: '^', ++ ++ /* ^ */ ++ CHAR_COLON: ':', ++ ++ /* : */ ++ CHAR_COMMA: ',', ++ ++ /* , */ ++ CHAR_DOLLAR: '$', ++ ++ /* . */ ++ CHAR_DOT: '.', ++ ++ /* . */ ++ CHAR_DOUBLE_QUOTE: '"', ++ ++ /* " */ ++ CHAR_EQUAL: '=', ++ ++ /* = */ ++ CHAR_EXCLAMATION_MARK: '!', ++ ++ /* ! */ ++ CHAR_FORM_FEED: '\f', ++ ++ /* \f */ ++ CHAR_FORWARD_SLASH: '/', ++ ++ /* / */ ++ CHAR_HASH: '#', ++ ++ /* # */ ++ CHAR_HYPHEN_MINUS: '-', ++ ++ /* - */ ++ CHAR_LEFT_ANGLE_BRACKET: '<', ++ ++ /* < */ ++ CHAR_LEFT_CURLY_BRACE: '{', ++ ++ /* { */ ++ CHAR_LEFT_SQUARE_BRACKET: '[', ++ ++ /* [ */ ++ CHAR_LINE_FEED: '\n', ++ ++ /* \n */ ++ CHAR_NO_BREAK_SPACE: '\u00A0', ++ ++ /* \u00A0 */ ++ CHAR_PERCENT: '%', ++ ++ /* % */ ++ CHAR_PLUS: '+', ++ ++ /* + */ ++ CHAR_QUESTION_MARK: '?', ++ ++ /* ? */ ++ CHAR_RIGHT_ANGLE_BRACKET: '>', ++ ++ /* > */ ++ CHAR_RIGHT_CURLY_BRACE: '}', ++ ++ /* } */ ++ CHAR_RIGHT_SQUARE_BRACKET: ']', ++ ++ /* ] */ ++ CHAR_SEMICOLON: ';', ++ ++ /* ; */ ++ CHAR_SINGLE_QUOTE: '\'', ++ ++ /* ' */ ++ CHAR_SPACE: ' ', ++ ++ /* */ ++ CHAR_TAB: '\t', ++ ++ /* \t */ ++ CHAR_UNDERSCORE: '_', ++ ++ /* _ */ ++ CHAR_VERTICAL_LINE: '|', ++ ++ /* | */ ++ CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\uFEFF' ++ /* \uFEFF */ ++ ++}; ++ ++/** ++ * Constants ++ */ ++ ++ ++const { ++ MAX_LENGTH: MAX_LENGTH$2, ++ CHAR_BACKSLASH, ++ ++ /* \ */ ++ CHAR_BACKTICK, ++ ++ /* ` */ ++ CHAR_COMMA: CHAR_COMMA$1, ++ ++ /* , */ ++ CHAR_DOT, ++ ++ /* . */ ++ CHAR_LEFT_PARENTHESES, ++ ++ /* ( */ ++ CHAR_RIGHT_PARENTHESES, ++ ++ /* ) */ ++ CHAR_LEFT_CURLY_BRACE, ++ ++ /* { */ ++ CHAR_RIGHT_CURLY_BRACE, ++ ++ /* } */ ++ CHAR_LEFT_SQUARE_BRACKET, ++ ++ /* [ */ ++ CHAR_RIGHT_SQUARE_BRACKET, ++ ++ /* ] */ ++ CHAR_DOUBLE_QUOTE, ++ ++ /* " */ ++ CHAR_SINGLE_QUOTE, ++ ++ /* ' */ ++ CHAR_NO_BREAK_SPACE, ++ CHAR_ZERO_WIDTH_NOBREAK_SPACE ++} = constants$1; ++/** ++ * parse ++ */ ++ ++const parse$2 = (input, options = {}) => { ++ if (typeof input !== 'string') { ++ throw new TypeError('Expected a string'); ++ } ++ ++ let opts = options || {}; ++ let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$2, opts.maxLength) : MAX_LENGTH$2; ++ ++ if (input.length > max) { ++ throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`); ++ } ++ ++ let ast = { ++ type: 'root', ++ input, ++ nodes: [] ++ }; ++ let stack = [ast]; ++ let block = ast; ++ let prev = ast; ++ let brackets = 0; ++ let length = input.length; ++ let index = 0; ++ let depth = 0; ++ let value; ++ /** ++ * Helpers ++ */ ++ ++ const advance = () => input[index++]; ++ ++ const push = node => { ++ if (node.type === 'text' && prev.type === 'dot') { ++ prev.type = 'text'; ++ } ++ ++ if (prev && prev.type === 'text' && node.type === 'text') { ++ prev.value += node.value; ++ return; ++ } ++ ++ block.nodes.push(node); ++ node.parent = block; ++ node.prev = prev; ++ prev = node; ++ return node; ++ }; ++ ++ push({ ++ type: 'bos' ++ }); ++ ++ while (index < length) { ++ block = stack[stack.length - 1]; ++ value = advance(); ++ /** ++ * Invalid chars ++ */ ++ ++ if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) { ++ continue; ++ } ++ /** ++ * Escaped chars ++ */ ++ ++ ++ if (value === CHAR_BACKSLASH) { ++ push({ ++ type: 'text', ++ value: (options.keepEscaping ? value : '') + advance() ++ }); ++ continue; ++ } ++ /** ++ * Right square bracket (literal): ']' ++ */ ++ ++ ++ if (value === CHAR_RIGHT_SQUARE_BRACKET) { ++ push({ ++ type: 'text', ++ value: '\\' + value ++ }); ++ continue; ++ } ++ /** ++ * Left square bracket: '[' ++ */ ++ ++ ++ if (value === CHAR_LEFT_SQUARE_BRACKET) { ++ brackets++; ++ let next; ++ ++ while (index < length && (next = advance())) { ++ value += next; ++ ++ if (next === CHAR_LEFT_SQUARE_BRACKET) { ++ brackets++; ++ continue; ++ } ++ ++ if (next === CHAR_BACKSLASH) { ++ value += advance(); ++ continue; ++ } ++ ++ if (next === CHAR_RIGHT_SQUARE_BRACKET) { ++ brackets--; ++ ++ if (brackets === 0) { ++ break; ++ } ++ } ++ } ++ ++ push({ ++ type: 'text', ++ value ++ }); ++ continue; ++ } ++ /** ++ * Parentheses ++ */ ++ ++ ++ if (value === CHAR_LEFT_PARENTHESES) { ++ block = push({ ++ type: 'paren', ++ nodes: [] ++ }); ++ stack.push(block); ++ push({ ++ type: 'text', ++ value ++ }); ++ continue; ++ } ++ ++ if (value === CHAR_RIGHT_PARENTHESES) { ++ if (block.type !== 'paren') { ++ push({ ++ type: 'text', ++ value ++ }); ++ continue; ++ } ++ ++ block = stack.pop(); ++ push({ ++ type: 'text', ++ value ++ }); ++ block = stack[stack.length - 1]; ++ continue; ++ } ++ /** ++ * Quotes: '|"|` ++ */ ++ ++ ++ if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) { ++ let open = value; ++ let next; ++ ++ if (options.keepQuotes !== true) { ++ value = ''; ++ } ++ ++ while (index < length && (next = advance())) { ++ if (next === CHAR_BACKSLASH) { ++ value += next + advance(); ++ continue; ++ } ++ ++ if (next === open) { ++ if (options.keepQuotes === true) value += next; ++ break; ++ } ++ ++ value += next; ++ } ++ ++ push({ ++ type: 'text', ++ value ++ }); ++ continue; ++ } ++ /** ++ * Left curly brace: '{' ++ */ ++ ++ ++ if (value === CHAR_LEFT_CURLY_BRACE) { ++ depth++; ++ let dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true; ++ let brace = { ++ type: 'brace', ++ open: true, ++ close: false, ++ dollar, ++ depth, ++ commas: 0, ++ ranges: 0, ++ nodes: [] ++ }; ++ block = push(brace); ++ stack.push(block); ++ push({ ++ type: 'open', ++ value ++ }); ++ continue; ++ } ++ /** ++ * Right curly brace: '}' ++ */ ++ ++ ++ if (value === CHAR_RIGHT_CURLY_BRACE) { ++ if (block.type !== 'brace') { ++ push({ ++ type: 'text', ++ value ++ }); ++ continue; ++ } ++ ++ let type = 'close'; ++ block = stack.pop(); ++ block.close = true; ++ push({ ++ type, ++ value ++ }); ++ depth--; ++ block = stack[stack.length - 1]; ++ continue; ++ } ++ /** ++ * Comma: ',' ++ */ ++ ++ ++ if (value === CHAR_COMMA$1 && depth > 0) { ++ if (block.ranges > 0) { ++ block.ranges = 0; ++ let open = block.nodes.shift(); ++ block.nodes = [open, { ++ type: 'text', ++ value: stringify(block) ++ }]; ++ } ++ ++ push({ ++ type: 'comma', ++ value ++ }); ++ block.commas++; ++ continue; ++ } ++ /** ++ * Dot: '.' ++ */ ++ ++ ++ if (value === CHAR_DOT && depth > 0 && block.commas === 0) { ++ let siblings = block.nodes; ++ ++ if (depth === 0 || siblings.length === 0) { ++ push({ ++ type: 'text', ++ value ++ }); ++ continue; ++ } ++ ++ if (prev.type === 'dot') { ++ block.range = []; ++ prev.value += value; ++ prev.type = 'range'; ++ ++ if (block.nodes.length !== 3 && block.nodes.length !== 5) { ++ block.invalid = true; ++ block.ranges = 0; ++ prev.type = 'text'; ++ continue; ++ } ++ ++ block.ranges++; ++ block.args = []; ++ continue; ++ } ++ ++ if (prev.type === 'range') { ++ siblings.pop(); ++ let before = siblings[siblings.length - 1]; ++ before.value += prev.value + value; ++ prev = before; ++ block.ranges--; ++ continue; ++ } ++ ++ push({ ++ type: 'dot', ++ value ++ }); ++ continue; ++ } ++ /** ++ * Text ++ */ ++ ++ ++ push({ ++ type: 'text', ++ value ++ }); ++ } // Mark imbalanced braces and brackets as invalid ++ ++ ++ do { ++ block = stack.pop(); ++ ++ if (block.type !== 'root') { ++ block.nodes.forEach(node => { ++ if (!node.nodes) { ++ if (node.type === 'open') node.isOpen = true; ++ if (node.type === 'close') node.isClose = true; ++ if (!node.nodes) node.type = 'text'; ++ node.invalid = true; ++ } ++ }); // get the location of the block on parent.nodes (block's siblings) ++ ++ let parent = stack[stack.length - 1]; ++ let index = parent.nodes.indexOf(block); // replace the (invalid) block with it's nodes ++ ++ parent.nodes.splice(index, 1, ...block.nodes); ++ } ++ } while (stack.length > 0); ++ ++ push({ ++ type: 'eos' ++ }); ++ return ast; ++}; ++ ++var parse_1 = parse$2; ++ ++/** ++ * Expand the given pattern or create a regex-compatible string. ++ * ++ * ```js ++ * const braces = require('braces'); ++ * console.log(braces('{a,b,c}', { compile: true })); //=> ['(a|b|c)'] ++ * console.log(braces('{a,b,c}')); //=> ['a', 'b', 'c'] ++ * ``` ++ * @param {String} `str` ++ * @param {Object} `options` ++ * @return {String} ++ * @api public ++ */ ++ ++ ++const braces = (input, options = {}) => { ++ let output = []; ++ ++ if (Array.isArray(input)) { ++ for (let pattern of input) { ++ let result = braces.create(pattern, options); ++ ++ if (Array.isArray(result)) { ++ output.push(...result); ++ } else { ++ output.push(result); ++ } ++ } ++ } else { ++ output = [].concat(braces.create(input, options)); ++ } ++ ++ if (options && options.expand === true && options.nodupes === true) { ++ output = [...new Set(output)]; ++ } ++ ++ return output; ++}; ++/** ++ * Parse the given `str` with the given `options`. ++ * ++ * ```js ++ * // braces.parse(pattern, [, options]); ++ * const ast = braces.parse('a/{b,c}/d'); ++ * console.log(ast); ++ * ``` ++ * @param {String} pattern Brace pattern to parse ++ * @param {Object} options ++ * @return {Object} Returns an AST ++ * @api public ++ */ ++ ++ ++braces.parse = (input, options = {}) => parse_1(input, options); ++/** ++ * Creates a braces string from an AST, or an AST node. ++ * ++ * ```js ++ * const braces = require('braces'); ++ * let ast = braces.parse('foo/{a,b}/bar'); ++ * console.log(stringify(ast.nodes[2])); //=> '{a,b}' ++ * ``` ++ * @param {String} `input` Brace pattern or AST. ++ * @param {Object} `options` ++ * @return {Array} Returns an array of expanded values. ++ * @api public ++ */ ++ ++ ++braces.stringify = (input, options = {}) => { ++ if (typeof input === 'string') { ++ return stringify(braces.parse(input, options), options); ++ } ++ ++ return stringify(input, options); ++}; ++/** ++ * Compiles a brace pattern into a regex-compatible, optimized string. ++ * This method is called by the main [braces](#braces) function by default. ++ * ++ * ```js ++ * const braces = require('braces'); ++ * console.log(braces.compile('a/{b,c}/d')); ++ * //=> ['a/(b|c)/d'] ++ * ``` ++ * @param {String} `input` Brace pattern or AST. ++ * @param {Object} `options` ++ * @return {Array} Returns an array of expanded values. ++ * @api public ++ */ ++ ++ ++braces.compile = (input, options = {}) => { ++ if (typeof input === 'string') { ++ input = braces.parse(input, options); ++ } ++ ++ return compile_1(input, options); ++}; ++/** ++ * Expands a brace pattern into an array. This method is called by the ++ * main [braces](#braces) function when `options.expand` is true. Before ++ * using this method it's recommended that you read the [performance notes](#performance)) ++ * and advantages of using [.compile](#compile) instead. ++ * ++ * ```js ++ * const braces = require('braces'); ++ * console.log(braces.expand('a/{b,c}/d')); ++ * //=> ['a/b/d', 'a/c/d']; ++ * ``` ++ * @param {String} `pattern` Brace pattern ++ * @param {Object} `options` ++ * @return {Array} Returns an array of expanded values. ++ * @api public ++ */ ++ ++ ++braces.expand = (input, options = {}) => { ++ if (typeof input === 'string') { ++ input = braces.parse(input, options); ++ } ++ ++ let result = expand_1(input, options); // filter out empty strings if specified ++ ++ if (options.noempty === true) { ++ result = result.filter(Boolean); ++ } // filter out duplicates if specified ++ ++ ++ if (options.nodupes === true) { ++ result = [...new Set(result)]; ++ } ++ ++ return result; ++}; ++/** ++ * Processes a brace pattern and returns either an expanded array ++ * (if `options.expand` is true), a highly optimized regex-compatible string. ++ * This method is called by the main [braces](#braces) function. ++ * ++ * ```js ++ * const braces = require('braces'); ++ * console.log(braces.create('user-{200..300}/project-{a,b,c}-{1..10}')) ++ * //=> 'user-(20[0-9]|2[1-9][0-9]|300)/project-(a|b|c)-([1-9]|10)' ++ * ``` ++ * @param {String} `pattern` Brace pattern ++ * @param {Object} `options` ++ * @return {Array} Returns an array of expanded values. ++ * @api public ++ */ ++ ++ ++braces.create = (input, options = {}) => { ++ if (input === '' || input.length < 3) { ++ return [input]; ++ } ++ ++ return options.expand !== true ? braces.compile(input, options) : braces.expand(input, options); ++}; ++/** ++ * Expose "braces" ++ */ ++ ++ ++var braces_1 = braces; ++ ++const WIN_SLASH = '\\\\/'; ++const WIN_NO_SLASH = `[^${WIN_SLASH}]`; ++/** ++ * Posix glob regex ++ */ ++ ++const DOT_LITERAL = '\\.'; ++const PLUS_LITERAL = '\\+'; ++const QMARK_LITERAL = '\\?'; ++const SLASH_LITERAL = '\\/'; ++const ONE_CHAR = '(?=.)'; ++const QMARK = '[^/]'; ++const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`; ++const START_ANCHOR = `(?:^|${SLASH_LITERAL})`; ++const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`; ++const NO_DOT = `(?!${DOT_LITERAL})`; ++const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`; ++const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`; ++const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`; ++const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`; ++const STAR = `${QMARK}*?`; ++const POSIX_CHARS = { ++ DOT_LITERAL, ++ PLUS_LITERAL, ++ QMARK_LITERAL, ++ SLASH_LITERAL, ++ ONE_CHAR, ++ QMARK, ++ END_ANCHOR, ++ DOTS_SLASH, ++ NO_DOT, ++ NO_DOTS, ++ NO_DOT_SLASH, ++ NO_DOTS_SLASH, ++ QMARK_NO_DOT, ++ STAR, ++ START_ANCHOR ++}; ++/** ++ * Windows glob regex ++ */ ++ ++const WINDOWS_CHARS = Object.assign({}, POSIX_CHARS, { ++ SLASH_LITERAL: `[${WIN_SLASH}]`, ++ QMARK: WIN_NO_SLASH, ++ STAR: `${WIN_NO_SLASH}*?`, ++ DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`, ++ NO_DOT: `(?!${DOT_LITERAL})`, ++ NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`, ++ NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`, ++ NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`, ++ QMARK_NO_DOT: `[^.${WIN_SLASH}]`, ++ START_ANCHOR: `(?:^|[${WIN_SLASH}])`, ++ END_ANCHOR: `(?:[${WIN_SLASH}]|$)` ++}); ++/** ++ * POSIX Bracket Regex ++ */ ++ ++const POSIX_REGEX_SOURCE = { ++ alnum: 'a-zA-Z0-9', ++ alpha: 'a-zA-Z', ++ ascii: '\\x00-\\x7F', ++ blank: ' \\t', ++ cntrl: '\\x00-\\x1F\\x7F', ++ digit: '0-9', ++ graph: '\\x21-\\x7E', ++ lower: 'a-z', ++ print: '\\x20-\\x7E ', ++ punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~', ++ space: ' \\t\\r\\n\\v\\f', ++ upper: 'A-Z', ++ word: 'A-Za-z0-9_', ++ xdigit: 'A-Fa-f0-9' ++}; ++var constants$2 = { ++ MAX_LENGTH: 1024 * 64, ++ POSIX_REGEX_SOURCE, ++ // regular expressions ++ REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g, ++ REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/, ++ REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/, ++ REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g, ++ REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g, ++ REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g, ++ // Replace globs with equivalent patterns to reduce parsing time. ++ REPLACEMENTS: { ++ '***': '*', ++ '**/**': '**', ++ '**/**/**': '**' ++ }, ++ // Digits ++ CHAR_0: 48, ++ ++ /* 0 */ ++ CHAR_9: 57, ++ ++ /* 9 */ ++ // Alphabet chars. ++ CHAR_UPPERCASE_A: 65, ++ ++ /* A */ ++ CHAR_LOWERCASE_A: 97, ++ ++ /* a */ ++ CHAR_UPPERCASE_Z: 90, ++ ++ /* Z */ ++ CHAR_LOWERCASE_Z: 122, ++ ++ /* z */ ++ CHAR_LEFT_PARENTHESES: 40, ++ ++ /* ( */ ++ CHAR_RIGHT_PARENTHESES: 41, ++ ++ /* ) */ ++ CHAR_ASTERISK: 42, ++ ++ /* * */ ++ // Non-alphabetic chars. ++ CHAR_AMPERSAND: 38, ++ ++ /* & */ ++ CHAR_AT: 64, ++ ++ /* @ */ ++ CHAR_BACKWARD_SLASH: 92, ++ ++ /* \ */ ++ CHAR_CARRIAGE_RETURN: 13, ++ ++ /* \r */ ++ CHAR_CIRCUMFLEX_ACCENT: 94, ++ ++ /* ^ */ ++ CHAR_COLON: 58, ++ ++ /* : */ ++ CHAR_COMMA: 44, ++ ++ /* , */ ++ CHAR_DOT: 46, ++ ++ /* . */ ++ CHAR_DOUBLE_QUOTE: 34, ++ ++ /* " */ ++ CHAR_EQUAL: 61, ++ ++ /* = */ ++ CHAR_EXCLAMATION_MARK: 33, ++ ++ /* ! */ ++ CHAR_FORM_FEED: 12, ++ ++ /* \f */ ++ CHAR_FORWARD_SLASH: 47, ++ ++ /* / */ ++ CHAR_GRAVE_ACCENT: 96, ++ ++ /* ` */ ++ CHAR_HASH: 35, ++ ++ /* # */ ++ CHAR_HYPHEN_MINUS: 45, ++ ++ /* - */ ++ CHAR_LEFT_ANGLE_BRACKET: 60, ++ ++ /* < */ ++ CHAR_LEFT_CURLY_BRACE: 123, ++ ++ /* { */ ++ CHAR_LEFT_SQUARE_BRACKET: 91, ++ ++ /* [ */ ++ CHAR_LINE_FEED: 10, ++ ++ /* \n */ ++ CHAR_NO_BREAK_SPACE: 160, ++ ++ /* \u00A0 */ ++ CHAR_PERCENT: 37, ++ ++ /* % */ ++ CHAR_PLUS: 43, ++ ++ /* + */ ++ CHAR_QUESTION_MARK: 63, ++ ++ /* ? */ ++ CHAR_RIGHT_ANGLE_BRACKET: 62, ++ ++ /* > */ ++ CHAR_RIGHT_CURLY_BRACE: 125, ++ ++ /* } */ ++ CHAR_RIGHT_SQUARE_BRACKET: 93, ++ ++ /* ] */ ++ CHAR_SEMICOLON: 59, ++ ++ /* ; */ ++ CHAR_SINGLE_QUOTE: 39, ++ ++ /* ' */ ++ CHAR_SPACE: 32, ++ ++ /* */ ++ CHAR_TAB: 9, ++ ++ /* \t */ ++ CHAR_UNDERSCORE: 95, ++ ++ /* _ */ ++ CHAR_VERTICAL_LINE: 124, ++ ++ /* | */ ++ CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, ++ ++ /* \uFEFF */ ++ SEP: path$1.sep, ++ ++ /** ++ * Create EXTGLOB_CHARS ++ */ ++ extglobChars(chars) { ++ return { ++ '!': { ++ type: 'negate', ++ open: '(?:(?!(?:', ++ close: `))${chars.STAR})` ++ }, ++ '?': { ++ type: 'qmark', ++ open: '(?:', ++ close: ')?' ++ }, ++ '+': { ++ type: 'plus', ++ open: '(?:', ++ close: ')+' ++ }, ++ '*': { ++ type: 'star', ++ open: '(?:', ++ close: ')*' ++ }, ++ '@': { ++ type: 'at', ++ open: '(?:', ++ close: ')' ++ } ++ }; ++ }, ++ ++ /** ++ * Create GLOB_CHARS ++ */ ++ globChars(win32) { ++ return win32 === true ? WINDOWS_CHARS : POSIX_CHARS; ++ } ++ ++}; ++ ++var utils$3 = createCommonjsModule(function (module, exports) { ++ ++ const win32 = process.platform === 'win32'; ++ const { ++ REGEX_BACKSLASH, ++ REGEX_REMOVE_BACKSLASH, ++ REGEX_SPECIAL_CHARS, ++ REGEX_SPECIAL_CHARS_GLOBAL ++ } = constants$2; ++ ++ exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val); ++ ++ exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str); ++ ++ exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str); ++ ++ exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1'); ++ ++ exports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/'); ++ ++ exports.removeBackslashes = str => { ++ return str.replace(REGEX_REMOVE_BACKSLASH, match => { ++ return match === '\\' ? '' : match; ++ }); ++ }; ++ ++ exports.supportsLookbehinds = () => { ++ const segs = process.version.slice(1).split('.').map(Number); ++ ++ if (segs.length === 3 && segs[0] >= 9 || segs[0] === 8 && segs[1] >= 10) { ++ return true; ++ } ++ ++ return false; ++ }; ++ ++ exports.isWindows = options => { ++ if (options && typeof options.windows === 'boolean') { ++ return options.windows; ++ } ++ ++ return win32 === true || path$1.sep === '\\'; ++ }; ++ ++ exports.escapeLast = (input, char, lastIdx) => { ++ const idx = input.lastIndexOf(char, lastIdx); ++ if (idx === -1) return input; ++ if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1); ++ return `${input.slice(0, idx)}\\${input.slice(idx)}`; ++ }; ++ ++ exports.removePrefix = (input, state = {}) => { ++ let output = input; ++ ++ if (output.startsWith('./')) { ++ output = output.slice(2); ++ state.prefix = './'; ++ } ++ ++ return output; ++ }; ++ ++ exports.wrapOutput = (input, state = {}, options = {}) => { ++ const prepend = options.contains ? '' : '^'; ++ const append = options.contains ? '' : '$'; ++ let output = `${prepend}(?:${input})${append}`; ++ ++ if (state.negated === true) { ++ output = `(?:^(?!${output}).*$)`; ++ } ++ ++ return output; ++ }; ++}); ++var utils_1$3 = utils$3.isObject; ++var utils_2$3 = utils$3.hasRegexChars; ++var utils_3$3 = utils$3.isRegexChar; ++var utils_4$2 = utils$3.escapeRegex; ++var utils_5$2 = utils$3.toPosixSlashes; ++var utils_6$2 = utils$3.removeBackslashes; ++var utils_7$2 = utils$3.supportsLookbehinds; ++var utils_8$2 = utils$3.isWindows; ++var utils_9$2 = utils$3.escapeLast; ++var utils_10$1 = utils$3.removePrefix; ++var utils_11$1 = utils$3.wrapOutput; ++ ++const { ++ CHAR_ASTERISK, ++ ++ /* * */ ++ CHAR_AT, ++ ++ /* @ */ ++ CHAR_BACKWARD_SLASH, ++ ++ /* \ */ ++ CHAR_COMMA: CHAR_COMMA$2, ++ ++ /* , */ ++ CHAR_DOT: CHAR_DOT$1, ++ ++ /* . */ ++ CHAR_EXCLAMATION_MARK, ++ ++ /* ! */ ++ CHAR_FORWARD_SLASH, ++ ++ /* / */ ++ CHAR_LEFT_CURLY_BRACE: CHAR_LEFT_CURLY_BRACE$1, ++ ++ /* { */ ++ CHAR_LEFT_PARENTHESES: CHAR_LEFT_PARENTHESES$1, ++ ++ /* ( */ ++ CHAR_LEFT_SQUARE_BRACKET: CHAR_LEFT_SQUARE_BRACKET$1, ++ ++ /* [ */ ++ CHAR_PLUS: CHAR_PLUS$1, ++ ++ /* + */ ++ CHAR_QUESTION_MARK, ++ ++ /* ? */ ++ CHAR_RIGHT_CURLY_BRACE: CHAR_RIGHT_CURLY_BRACE$1, ++ ++ /* } */ ++ CHAR_RIGHT_PARENTHESES: CHAR_RIGHT_PARENTHESES$1, ++ ++ /* ) */ ++ CHAR_RIGHT_SQUARE_BRACKET: CHAR_RIGHT_SQUARE_BRACKET$1 ++ /* ] */ ++ ++} = constants$2; ++ ++const isPathSeparator = code => { ++ return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH; ++}; ++ ++const depth = token => { ++ if (token.isPrefix !== true) { ++ token.depth = token.isGlobstar ? Infinity : 1; ++ } ++}; ++/** ++ * Quickly scans a glob pattern and returns an object with a handful of ++ * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists), ++ * `glob` (the actual pattern), and `negated` (true if the path starts with `!`). ++ * ++ * ```js ++ * const pm = require('picomatch'); ++ * console.log(pm.scan('foo/bar/*.js')); ++ * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' } ++ * ``` ++ * @param {String} `str` ++ * @param {Object} `options` ++ * @return {Object} Returns an object with tokens and regex source string. ++ * @api public ++ */ ++ ++ ++const scan = (input, options) => { ++ const opts = options || {}; ++ const length = input.length - 1; ++ const scanToEnd = opts.parts === true || opts.scanToEnd === true; ++ const slashes = []; ++ const tokens = []; ++ const parts = []; ++ let str = input; ++ let index = -1; ++ let start = 0; ++ let lastIndex = 0; ++ let isBrace = false; ++ let isBracket = false; ++ let isGlob = false; ++ let isExtglob = false; ++ let isGlobstar = false; ++ let braceEscaped = false; ++ let backslashes = false; ++ let negated = false; ++ let finished = false; ++ let braces = 0; ++ let prev; ++ let code; ++ let token = { ++ value: '', ++ depth: 0, ++ isGlob: false ++ }; ++ ++ const eos = () => index >= length; ++ ++ const peek = () => str.charCodeAt(index + 1); ++ ++ const advance = () => { ++ prev = code; ++ return str.charCodeAt(++index); ++ }; ++ ++ while (index < length) { ++ code = advance(); ++ let next; ++ ++ if (code === CHAR_BACKWARD_SLASH) { ++ backslashes = token.backslashes = true; ++ code = advance(); ++ ++ if (code === CHAR_LEFT_CURLY_BRACE$1) { ++ braceEscaped = true; ++ } ++ ++ continue; ++ } ++ ++ if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE$1) { ++ braces++; ++ ++ while (eos() !== true && (code = advance())) { ++ if (code === CHAR_BACKWARD_SLASH) { ++ backslashes = token.backslashes = true; ++ advance(); ++ continue; ++ } ++ ++ if (code === CHAR_LEFT_CURLY_BRACE$1) { ++ braces++; ++ continue; ++ } ++ ++ if (braceEscaped !== true && code === CHAR_DOT$1 && (code = advance()) === CHAR_DOT$1) { ++ isBrace = token.isBrace = true; ++ isGlob = token.isGlob = true; ++ finished = true; ++ ++ if (scanToEnd === true) { ++ continue; ++ } ++ ++ break; ++ } ++ ++ if (braceEscaped !== true && code === CHAR_COMMA$2) { ++ isBrace = token.isBrace = true; ++ isGlob = token.isGlob = true; ++ finished = true; ++ ++ if (scanToEnd === true) { ++ continue; ++ } ++ ++ break; ++ } ++ ++ if (code === CHAR_RIGHT_CURLY_BRACE$1) { ++ braces--; ++ ++ if (braces === 0) { ++ braceEscaped = false; ++ isBrace = token.isBrace = true; ++ finished = true; ++ break; ++ } ++ } ++ } ++ ++ if (scanToEnd === true) { ++ continue; ++ } ++ ++ break; ++ } ++ ++ if (code === CHAR_FORWARD_SLASH) { ++ slashes.push(index); ++ tokens.push(token); ++ token = { ++ value: '', ++ depth: 0, ++ isGlob: false ++ }; ++ if (finished === true) continue; ++ ++ if (prev === CHAR_DOT$1 && index === start + 1) { ++ start += 2; ++ continue; ++ } ++ ++ lastIndex = index + 1; ++ continue; ++ } ++ ++ if (opts.noext !== true) { ++ const isExtglobChar = code === CHAR_PLUS$1 || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK; ++ ++ if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES$1) { ++ isGlob = token.isGlob = true; ++ isExtglob = token.isExtglob = true; ++ finished = true; ++ ++ if (scanToEnd === true) { ++ while (eos() !== true && (code = advance())) { ++ if (code === CHAR_BACKWARD_SLASH) { ++ backslashes = token.backslashes = true; ++ code = advance(); ++ continue; ++ } ++ ++ if (code === CHAR_RIGHT_PARENTHESES$1) { ++ isGlob = token.isGlob = true; ++ finished = true; ++ break; ++ } ++ } ++ ++ continue; ++ } ++ ++ break; ++ } ++ } ++ ++ if (code === CHAR_ASTERISK) { ++ if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true; ++ isGlob = token.isGlob = true; ++ finished = true; ++ ++ if (scanToEnd === true) { ++ continue; ++ } ++ ++ break; ++ } ++ ++ if (code === CHAR_QUESTION_MARK) { ++ isGlob = token.isGlob = true; ++ finished = true; ++ ++ if (scanToEnd === true) { ++ continue; ++ } ++ ++ break; ++ } ++ ++ if (code === CHAR_LEFT_SQUARE_BRACKET$1) { ++ while (eos() !== true && (next = advance())) { ++ if (next === CHAR_BACKWARD_SLASH) { ++ backslashes = token.backslashes = true; ++ advance(); ++ continue; ++ } ++ ++ if (next === CHAR_RIGHT_SQUARE_BRACKET$1) { ++ isBracket = token.isBracket = true; ++ isGlob = token.isGlob = true; ++ finished = true; ++ ++ if (scanToEnd === true) { ++ continue; ++ } ++ ++ break; ++ } ++ } ++ } ++ ++ if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) { ++ negated = token.negated = true; ++ start++; ++ continue; ++ } ++ ++ if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES$1) { ++ while (eos() !== true && (code = advance())) { ++ if (code === CHAR_BACKWARD_SLASH) { ++ backslashes = token.backslashes = true; ++ code = advance(); ++ continue; ++ } ++ ++ if (code === CHAR_RIGHT_PARENTHESES$1) { ++ isGlob = token.isGlob = true; ++ finished = true; ++ ++ if (scanToEnd === true) { ++ continue; ++ } ++ ++ break; ++ } ++ } ++ } ++ ++ if (isGlob === true) { ++ finished = true; ++ ++ if (scanToEnd === true) { ++ continue; ++ } ++ ++ break; ++ } ++ } ++ ++ if (opts.noext === true) { ++ isExtglob = false; ++ isGlob = false; ++ } ++ ++ let base = str; ++ let prefix = ''; ++ let glob = ''; ++ ++ if (start > 0) { ++ prefix = str.slice(0, start); ++ str = str.slice(start); ++ lastIndex -= start; ++ } ++ ++ if (base && isGlob === true && lastIndex > 0) { ++ base = str.slice(0, lastIndex); ++ glob = str.slice(lastIndex); ++ } else if (isGlob === true) { ++ base = ''; ++ glob = str; ++ } else { ++ base = str; ++ } ++ ++ if (base && base !== '' && base !== '/' && base !== str) { ++ if (isPathSeparator(base.charCodeAt(base.length - 1))) { ++ base = base.slice(0, -1); ++ } ++ } ++ ++ if (opts.unescape === true) { ++ if (glob) glob = utils$3.removeBackslashes(glob); ++ ++ if (base && backslashes === true) { ++ base = utils$3.removeBackslashes(base); ++ } ++ } ++ ++ const state = { ++ prefix, ++ input, ++ start, ++ base, ++ glob, ++ isBrace, ++ isBracket, ++ isGlob, ++ isExtglob, ++ isGlobstar, ++ negated ++ }; ++ ++ if (opts.tokens === true) { ++ state.maxDepth = 0; ++ ++ if (!isPathSeparator(code)) { ++ tokens.push(token); ++ } ++ ++ state.tokens = tokens; ++ } ++ ++ if (opts.parts === true || opts.tokens === true) { ++ let prevIndex; ++ ++ for (let idx = 0; idx < slashes.length; idx++) { ++ const n = prevIndex ? prevIndex + 1 : start; ++ const i = slashes[idx]; ++ const value = input.slice(n, i); ++ ++ if (opts.tokens) { ++ if (idx === 0 && start !== 0) { ++ tokens[idx].isPrefix = true; ++ tokens[idx].value = prefix; ++ } else { ++ tokens[idx].value = value; ++ } ++ ++ depth(tokens[idx]); ++ state.maxDepth += tokens[idx].depth; ++ } ++ ++ if (idx !== 0 || value !== '') { ++ parts.push(value); ++ } ++ ++ prevIndex = i; ++ } ++ ++ if (prevIndex && prevIndex + 1 < input.length) { ++ const value = input.slice(prevIndex + 1); ++ parts.push(value); ++ ++ if (opts.tokens) { ++ tokens[tokens.length - 1].value = value; ++ depth(tokens[tokens.length - 1]); ++ state.maxDepth += tokens[tokens.length - 1].depth; ++ } ++ } ++ ++ state.slashes = slashes; ++ state.parts = parts; ++ } ++ ++ return state; ++}; ++ ++var scan_1 = scan; ++ ++/** ++ * Constants ++ */ ++ ++ ++const { ++ MAX_LENGTH: MAX_LENGTH$3, ++ POSIX_REGEX_SOURCE: POSIX_REGEX_SOURCE$1, ++ REGEX_NON_SPECIAL_CHARS, ++ REGEX_SPECIAL_CHARS_BACKREF, ++ REPLACEMENTS ++} = constants$2; ++/** ++ * Helpers ++ */ ++ ++const expandRange = (args, options) => { ++ if (typeof options.expandRange === 'function') { ++ return options.expandRange(...args, options); ++ } ++ ++ args.sort(); ++ const value = `[${args.join('-')}]`; ++ ++ try { ++ /* eslint-disable-next-line no-new */ ++ new RegExp(value); ++ } catch (ex) { ++ return args.map(v => utils$3.escapeRegex(v)).join('..'); ++ } ++ ++ return value; ++}; ++/** ++ * Create the message for a syntax error ++ */ ++ ++ ++const syntaxError = (type, char) => { ++ return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`; ++}; ++/** ++ * Parse the given input string. ++ * @param {String} input ++ * @param {Object} options ++ * @return {Object} ++ */ ++ ++ ++const parse$3 = (input, options) => { ++ if (typeof input !== 'string') { ++ throw new TypeError('Expected a string'); ++ } ++ ++ input = REPLACEMENTS[input] || input; ++ const opts = Object.assign({}, options); ++ const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$3, opts.maxLength) : MAX_LENGTH$3; ++ let len = input.length; ++ ++ if (len > max) { ++ throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`); ++ } ++ ++ const bos = { ++ type: 'bos', ++ value: '', ++ output: opts.prepend || '' ++ }; ++ const tokens = [bos]; ++ const capture = opts.capture ? '' : '?:'; ++ const win32 = utils$3.isWindows(options); // create constants based on platform, for windows or posix ++ ++ const PLATFORM_CHARS = constants$2.globChars(win32); ++ const EXTGLOB_CHARS = constants$2.extglobChars(PLATFORM_CHARS); ++ const { ++ DOT_LITERAL, ++ PLUS_LITERAL, ++ SLASH_LITERAL, ++ ONE_CHAR, ++ DOTS_SLASH, ++ NO_DOT, ++ NO_DOT_SLASH, ++ NO_DOTS_SLASH, ++ QMARK, ++ QMARK_NO_DOT, ++ STAR, ++ START_ANCHOR ++ } = PLATFORM_CHARS; ++ ++ const globstar = opts => { ++ return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`; ++ }; ++ ++ const nodot = opts.dot ? '' : NO_DOT; ++ const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT; ++ let star = opts.bash === true ? globstar(opts) : STAR; ++ ++ if (opts.capture) { ++ star = `(${star})`; ++ } // minimatch options support ++ ++ ++ if (typeof opts.noext === 'boolean') { ++ opts.noextglob = opts.noext; ++ } ++ ++ const state = { ++ input, ++ index: -1, ++ start: 0, ++ dot: opts.dot === true, ++ consumed: '', ++ output: '', ++ prefix: '', ++ backtrack: false, ++ negated: false, ++ brackets: 0, ++ braces: 0, ++ parens: 0, ++ quotes: 0, ++ globstar: false, ++ tokens ++ }; ++ input = utils$3.removePrefix(input, state); ++ len = input.length; ++ const extglobs = []; ++ const braces = []; ++ const stack = []; ++ let prev = bos; ++ let value; ++ /** ++ * Tokenizing helpers ++ */ ++ ++ const eos = () => state.index === len - 1; ++ ++ const peek = state.peek = (n = 1) => input[state.index + n]; ++ ++ const advance = state.advance = () => input[++state.index]; ++ ++ const remaining = () => input.slice(state.index + 1); ++ ++ const consume = (value = '', num = 0) => { ++ state.consumed += value; ++ state.index += num; ++ }; ++ ++ const append = token => { ++ state.output += token.output != null ? token.output : token.value; ++ consume(token.value); ++ }; ++ ++ const negate = () => { ++ let count = 1; ++ ++ while (peek() === '!' && (peek(2) !== '(' || peek(3) === '?')) { ++ advance(); ++ state.start++; ++ count++; ++ } ++ ++ if (count % 2 === 0) { ++ return false; ++ } ++ ++ state.negated = true; ++ state.start++; ++ return true; ++ }; ++ ++ const increment = type => { ++ state[type]++; ++ stack.push(type); ++ }; ++ ++ const decrement = type => { ++ state[type]--; ++ stack.pop(); ++ }; ++ /** ++ * Push tokens onto the tokens array. This helper speeds up ++ * tokenizing by 1) helping us avoid backtracking as much as possible, ++ * and 2) helping us avoid creating extra tokens when consecutive ++ * characters are plain text. This improves performance and simplifies ++ * lookbehinds. ++ */ ++ ++ ++ const push = tok => { ++ if (prev.type === 'globstar') { ++ const isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace'); ++ const isExtglob = tok.extglob === true || extglobs.length && (tok.type === 'pipe' || tok.type === 'paren'); ++ ++ if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) { ++ state.output = state.output.slice(0, -prev.output.length); ++ prev.type = 'star'; ++ prev.value = '*'; ++ prev.output = star; ++ state.output += prev.output; ++ } ++ } ++ ++ if (extglobs.length && tok.type !== 'paren' && !EXTGLOB_CHARS[tok.value]) { ++ extglobs[extglobs.length - 1].inner += tok.value; ++ } ++ ++ if (tok.value || tok.output) append(tok); ++ ++ if (prev && prev.type === 'text' && tok.type === 'text') { ++ prev.value += tok.value; ++ prev.output = (prev.output || '') + tok.value; ++ return; ++ } ++ ++ tok.prev = prev; ++ tokens.push(tok); ++ prev = tok; ++ }; ++ ++ const extglobOpen = (type, value) => { ++ const token = Object.assign({}, EXTGLOB_CHARS[value], { ++ conditions: 1, ++ inner: '' ++ }); ++ token.prev = prev; ++ token.parens = state.parens; ++ token.output = state.output; ++ const output = (opts.capture ? '(' : '') + token.open; ++ increment('parens'); ++ push({ ++ type, ++ value, ++ output: state.output ? '' : ONE_CHAR ++ }); ++ push({ ++ type: 'paren', ++ extglob: true, ++ value: advance(), ++ output ++ }); ++ extglobs.push(token); ++ }; ++ ++ const extglobClose = token => { ++ let output = token.close + (opts.capture ? ')' : ''); ++ ++ if (token.type === 'negate') { ++ let extglobStar = star; ++ ++ if (token.inner && token.inner.length > 1 && token.inner.includes('/')) { ++ extglobStar = globstar(opts); ++ } ++ ++ if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) { ++ output = token.close = `)$))${extglobStar}`; ++ } ++ ++ if (token.prev.type === 'bos' && eos()) { ++ state.negatedExtglob = true; ++ } ++ } ++ ++ push({ ++ type: 'paren', ++ extglob: true, ++ value, ++ output ++ }); ++ decrement('parens'); ++ }; ++ /** ++ * Fast paths ++ */ ++ ++ ++ if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) { ++ let backslashes = false; ++ let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => { ++ if (first === '\\') { ++ backslashes = true; ++ return m; ++ } ++ ++ if (first === '?') { ++ if (esc) { ++ return esc + first + (rest ? QMARK.repeat(rest.length) : ''); ++ } ++ ++ if (index === 0) { ++ return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : ''); ++ } ++ ++ return QMARK.repeat(chars.length); ++ } ++ ++ if (first === '.') { ++ return DOT_LITERAL.repeat(chars.length); ++ } ++ ++ if (first === '*') { ++ if (esc) { ++ return esc + first + (rest ? star : ''); ++ } ++ ++ return star; ++ } ++ ++ return esc ? m : `\\${m}`; ++ }); ++ ++ if (backslashes === true) { ++ if (opts.unescape === true) { ++ output = output.replace(/\\/g, ''); ++ } else { ++ output = output.replace(/\\+/g, m => { ++ return m.length % 2 === 0 ? '\\\\' : m ? '\\' : ''; ++ }); ++ } ++ } ++ ++ if (output === input && opts.contains === true) { ++ state.output = input; ++ return state; ++ } ++ ++ state.output = utils$3.wrapOutput(output, state, options); ++ return state; ++ } ++ /** ++ * Tokenize input until we reach end-of-string ++ */ ++ ++ ++ while (!eos()) { ++ value = advance(); ++ ++ if (value === '\u0000') { ++ continue; ++ } ++ /** ++ * Escaped characters ++ */ ++ ++ ++ if (value === '\\') { ++ const next = peek(); ++ ++ if (next === '/' && opts.bash !== true) { ++ continue; ++ } ++ ++ if (next === '.' || next === ';') { ++ continue; ++ } ++ ++ if (!next) { ++ value += '\\'; ++ push({ ++ type: 'text', ++ value ++ }); ++ continue; ++ } // collapse slashes to reduce potential for exploits ++ ++ ++ const match = /^\\+/.exec(remaining()); ++ let slashes = 0; ++ ++ if (match && match[0].length > 2) { ++ slashes = match[0].length; ++ state.index += slashes; ++ ++ if (slashes % 2 !== 0) { ++ value += '\\'; ++ } ++ } ++ ++ if (opts.unescape === true) { ++ value = advance() || ''; ++ } else { ++ value += advance() || ''; ++ } ++ ++ if (state.brackets === 0) { ++ push({ ++ type: 'text', ++ value ++ }); ++ continue; ++ } ++ } ++ /** ++ * If we're inside a regex character class, continue ++ * until we reach the closing bracket. ++ */ ++ ++ ++ if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) { ++ if (opts.posix !== false && value === ':') { ++ const inner = prev.value.slice(1); ++ ++ if (inner.includes('[')) { ++ prev.posix = true; ++ ++ if (inner.includes(':')) { ++ const idx = prev.value.lastIndexOf('['); ++ const pre = prev.value.slice(0, idx); ++ const rest = prev.value.slice(idx + 2); ++ const posix = POSIX_REGEX_SOURCE$1[rest]; ++ ++ if (posix) { ++ prev.value = pre + posix; ++ state.backtrack = true; ++ advance(); ++ ++ if (!bos.output && tokens.indexOf(prev) === 1) { ++ bos.output = ONE_CHAR; ++ } ++ ++ continue; ++ } ++ } ++ } ++ } ++ ++ if (value === '[' && peek() !== ':' || value === '-' && peek() === ']') { ++ value = `\\${value}`; ++ } ++ ++ if (value === ']' && (prev.value === '[' || prev.value === '[^')) { ++ value = `\\${value}`; ++ } ++ ++ if (opts.posix === true && value === '!' && prev.value === '[') { ++ value = '^'; ++ } ++ ++ prev.value += value; ++ append({ ++ value ++ }); ++ continue; ++ } ++ /** ++ * If we're inside a quoted string, continue ++ * until we reach the closing double quote. ++ */ ++ ++ ++ if (state.quotes === 1 && value !== '"') { ++ value = utils$3.escapeRegex(value); ++ prev.value += value; ++ append({ ++ value ++ }); ++ continue; ++ } ++ /** ++ * Double quotes ++ */ ++ ++ ++ if (value === '"') { ++ state.quotes = state.quotes === 1 ? 0 : 1; ++ ++ if (opts.keepQuotes === true) { ++ push({ ++ type: 'text', ++ value ++ }); ++ } ++ ++ continue; ++ } ++ /** ++ * Parentheses ++ */ ++ ++ ++ if (value === '(') { ++ increment('parens'); ++ push({ ++ type: 'paren', ++ value ++ }); ++ continue; ++ } ++ ++ if (value === ')') { ++ if (state.parens === 0 && opts.strictBrackets === true) { ++ throw new SyntaxError(syntaxError('opening', '(')); ++ } ++ ++ const extglob = extglobs[extglobs.length - 1]; ++ ++ if (extglob && state.parens === extglob.parens + 1) { ++ extglobClose(extglobs.pop()); ++ continue; ++ } ++ ++ push({ ++ type: 'paren', ++ value, ++ output: state.parens ? ')' : '\\)' ++ }); ++ decrement('parens'); ++ continue; ++ } ++ /** ++ * Square brackets ++ */ ++ ++ ++ if (value === '[') { ++ if (opts.nobracket === true || !remaining().includes(']')) { ++ if (opts.nobracket !== true && opts.strictBrackets === true) { ++ throw new SyntaxError(syntaxError('closing', ']')); ++ } ++ ++ value = `\\${value}`; ++ } else { ++ increment('brackets'); ++ } ++ ++ push({ ++ type: 'bracket', ++ value ++ }); ++ continue; ++ } ++ ++ if (value === ']') { ++ if (opts.nobracket === true || prev && prev.type === 'bracket' && prev.value.length === 1) { ++ push({ ++ type: 'text', ++ value, ++ output: `\\${value}` ++ }); ++ continue; ++ } ++ ++ if (state.brackets === 0) { ++ if (opts.strictBrackets === true) { ++ throw new SyntaxError(syntaxError('opening', '[')); ++ } ++ ++ push({ ++ type: 'text', ++ value, ++ output: `\\${value}` ++ }); ++ continue; ++ } ++ ++ decrement('brackets'); ++ const prevValue = prev.value.slice(1); ++ ++ if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) { ++ value = `/${value}`; ++ } ++ ++ prev.value += value; ++ append({ ++ value ++ }); // when literal brackets are explicitly disabled ++ // assume we should match with a regex character class ++ ++ if (opts.literalBrackets === false || utils$3.hasRegexChars(prevValue)) { ++ continue; ++ } ++ ++ const escaped = utils$3.escapeRegex(prev.value); ++ state.output = state.output.slice(0, -prev.value.length); // when literal brackets are explicitly enabled ++ // assume we should escape the brackets to match literal characters ++ ++ if (opts.literalBrackets === true) { ++ state.output += escaped; ++ prev.value = escaped; ++ continue; ++ } // when the user specifies nothing, try to match both ++ ++ ++ prev.value = `(${capture}${escaped}|${prev.value})`; ++ state.output += prev.value; ++ continue; ++ } ++ /** ++ * Braces ++ */ ++ ++ ++ if (value === '{' && opts.nobrace !== true) { ++ increment('braces'); ++ const open = { ++ type: 'brace', ++ value, ++ output: '(', ++ outputIndex: state.output.length, ++ tokensIndex: state.tokens.length ++ }; ++ braces.push(open); ++ push(open); ++ continue; ++ } ++ ++ if (value === '}') { ++ const brace = braces[braces.length - 1]; ++ ++ if (opts.nobrace === true || !brace) { ++ push({ ++ type: 'text', ++ value, ++ output: value ++ }); ++ continue; ++ } ++ ++ let output = ')'; ++ ++ if (brace.dots === true) { ++ const arr = tokens.slice(); ++ const range = []; ++ ++ for (let i = arr.length - 1; i >= 0; i--) { ++ tokens.pop(); ++ ++ if (arr[i].type === 'brace') { ++ break; ++ } ++ ++ if (arr[i].type !== 'dots') { ++ range.unshift(arr[i].value); ++ } ++ } ++ ++ output = expandRange(range, opts); ++ state.backtrack = true; ++ } ++ ++ if (brace.comma !== true && brace.dots !== true) { ++ const out = state.output.slice(0, brace.outputIndex); ++ const toks = state.tokens.slice(brace.tokensIndex); ++ brace.value = brace.output = '\\{'; ++ value = output = `\\}`; ++ state.output = out; ++ ++ for (const t of toks) { ++ state.output += t.output || t.value; ++ } ++ } ++ ++ push({ ++ type: 'brace', ++ value, ++ output ++ }); ++ decrement('braces'); ++ braces.pop(); ++ continue; ++ } ++ /** ++ * Pipes ++ */ ++ ++ ++ if (value === '|') { ++ if (extglobs.length > 0) { ++ extglobs[extglobs.length - 1].conditions++; ++ } ++ ++ push({ ++ type: 'text', ++ value ++ }); ++ continue; ++ } ++ /** ++ * Commas ++ */ ++ ++ ++ if (value === ',') { ++ let output = value; ++ const brace = braces[braces.length - 1]; ++ ++ if (brace && stack[stack.length - 1] === 'braces') { ++ brace.comma = true; ++ output = '|'; ++ } ++ ++ push({ ++ type: 'comma', ++ value, ++ output ++ }); ++ continue; ++ } ++ /** ++ * Slashes ++ */ ++ ++ ++ if (value === '/') { ++ // if the beginning of the glob is "./", advance the start ++ // to the current index, and don't add the "./" characters ++ // to the state. This greatly simplifies lookbehinds when ++ // checking for BOS characters like "!" and "." (not "./") ++ if (prev.type === 'dot' && state.index === state.start + 1) { ++ state.start = state.index + 1; ++ state.consumed = ''; ++ state.output = ''; ++ tokens.pop(); ++ prev = bos; // reset "prev" to the first token ++ ++ continue; ++ } ++ ++ push({ ++ type: 'slash', ++ value, ++ output: SLASH_LITERAL ++ }); ++ continue; ++ } ++ /** ++ * Dots ++ */ ++ ++ ++ if (value === '.') { ++ if (state.braces > 0 && prev.type === 'dot') { ++ if (prev.value === '.') prev.output = DOT_LITERAL; ++ const brace = braces[braces.length - 1]; ++ prev.type = 'dots'; ++ prev.output += value; ++ prev.value += value; ++ brace.dots = true; ++ continue; ++ } ++ ++ if (state.braces + state.parens === 0 && prev.type !== 'bos' && prev.type !== 'slash') { ++ push({ ++ type: 'text', ++ value, ++ output: DOT_LITERAL ++ }); ++ continue; ++ } ++ ++ push({ ++ type: 'dot', ++ value, ++ output: DOT_LITERAL ++ }); ++ continue; ++ } ++ /** ++ * Question marks ++ */ ++ ++ ++ if (value === '?') { ++ const isGroup = prev && prev.value === '('; ++ ++ if (!isGroup && opts.noextglob !== true && peek() === '(' && peek(2) !== '?') { ++ extglobOpen('qmark', value); ++ continue; ++ } ++ ++ if (prev && prev.type === 'paren') { ++ const next = peek(); ++ let output = value; ++ ++ if (next === '<' && !utils$3.supportsLookbehinds()) { ++ throw new Error('Node.js v10 or higher is required for regex lookbehinds'); ++ } ++ ++ if (prev.value === '(' && !/[!=<:]/.test(next) || next === '<' && !/<([!=]|\w+>)/.test(remaining())) { ++ output = `\\${value}`; ++ } ++ ++ push({ ++ type: 'text', ++ value, ++ output ++ }); ++ continue; ++ } ++ ++ if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) { ++ push({ ++ type: 'qmark', ++ value, ++ output: QMARK_NO_DOT ++ }); ++ continue; ++ } ++ ++ push({ ++ type: 'qmark', ++ value, ++ output: QMARK ++ }); ++ continue; ++ } ++ /** ++ * Exclamation ++ */ ++ ++ ++ if (value === '!') { ++ if (opts.noextglob !== true && peek() === '(') { ++ if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) { ++ extglobOpen('negate', value); ++ continue; ++ } ++ } ++ ++ if (opts.nonegate !== true && state.index === 0) { ++ negate(); ++ continue; ++ } ++ } ++ /** ++ * Plus ++ */ ++ ++ ++ if (value === '+') { ++ if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') { ++ extglobOpen('plus', value); ++ continue; ++ } ++ ++ if (prev && prev.value === '(' || opts.regex === false) { ++ push({ ++ type: 'plus', ++ value, ++ output: PLUS_LITERAL ++ }); ++ continue; ++ } ++ ++ if (prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace') || state.parens > 0) { ++ push({ ++ type: 'plus', ++ value ++ }); ++ continue; ++ } ++ ++ push({ ++ type: 'plus', ++ value: PLUS_LITERAL ++ }); ++ continue; ++ } ++ /** ++ * Plain text ++ */ ++ ++ ++ if (value === '@') { ++ if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') { ++ push({ ++ type: 'at', ++ extglob: true, ++ value, ++ output: '' ++ }); ++ continue; ++ } ++ ++ push({ ++ type: 'text', ++ value ++ }); ++ continue; ++ } ++ /** ++ * Plain text ++ */ ++ ++ ++ if (value !== '*') { ++ if (value === '$' || value === '^') { ++ value = `\\${value}`; ++ } ++ ++ const match = REGEX_NON_SPECIAL_CHARS.exec(remaining()); ++ ++ if (match) { ++ value += match[0]; ++ state.index += match[0].length; ++ } ++ ++ push({ ++ type: 'text', ++ value ++ }); ++ continue; ++ } ++ /** ++ * Stars ++ */ ++ ++ ++ if (prev && (prev.type === 'globstar' || prev.star === true)) { ++ prev.type = 'star'; ++ prev.star = true; ++ prev.value += value; ++ prev.output = star; ++ state.backtrack = true; ++ state.globstar = true; ++ consume(value); ++ continue; ++ } ++ ++ let rest = remaining(); ++ ++ if (opts.noextglob !== true && /^\([^?]/.test(rest)) { ++ extglobOpen('star', value); ++ continue; ++ } ++ ++ if (prev.type === 'star') { ++ if (opts.noglobstar === true) { ++ consume(value); ++ continue; ++ } ++ ++ const prior = prev.prev; ++ const before = prior.prev; ++ const isStart = prior.type === 'slash' || prior.type === 'bos'; ++ const afterStar = before && (before.type === 'star' || before.type === 'globstar'); ++ ++ if (opts.bash === true && (!isStart || rest[0] && rest[0] !== '/')) { ++ push({ ++ type: 'star', ++ value, ++ output: '' ++ }); ++ continue; ++ } ++ ++ const isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace'); ++ const isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren'); ++ ++ if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) { ++ push({ ++ type: 'star', ++ value, ++ output: '' ++ }); ++ continue; ++ } // strip consecutive `/**/` ++ ++ ++ while (rest.slice(0, 3) === '/**') { ++ const after = input[state.index + 4]; ++ ++ if (after && after !== '/') { ++ break; ++ } ++ ++ rest = rest.slice(3); ++ consume('/**', 3); ++ } ++ ++ if (prior.type === 'bos' && eos()) { ++ prev.type = 'globstar'; ++ prev.value += value; ++ prev.output = globstar(opts); ++ state.output = prev.output; ++ state.globstar = true; ++ consume(value); ++ continue; ++ } ++ ++ if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) { ++ state.output = state.output.slice(0, -(prior.output + prev.output).length); ++ prior.output = `(?:${prior.output}`; ++ prev.type = 'globstar'; ++ prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)'); ++ prev.value += value; ++ state.globstar = true; ++ state.output += prior.output + prev.output; ++ consume(value); ++ continue; ++ } ++ ++ if (prior.type === 'slash' && prior.prev.type !== 'bos' && rest[0] === '/') { ++ const end = rest[1] !== void 0 ? '|$' : ''; ++ state.output = state.output.slice(0, -(prior.output + prev.output).length); ++ prior.output = `(?:${prior.output}`; ++ prev.type = 'globstar'; ++ prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`; ++ prev.value += value; ++ state.output += prior.output + prev.output; ++ state.globstar = true; ++ consume(value + advance()); ++ push({ ++ type: 'slash', ++ value: '/', ++ output: '' ++ }); ++ continue; ++ } ++ ++ if (prior.type === 'bos' && rest[0] === '/') { ++ prev.type = 'globstar'; ++ prev.value += value; ++ prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`; ++ state.output = prev.output; ++ state.globstar = true; ++ consume(value + advance()); ++ push({ ++ type: 'slash', ++ value: '/', ++ output: '' ++ }); ++ continue; ++ } // remove single star from output ++ ++ ++ state.output = state.output.slice(0, -prev.output.length); // reset previous token to globstar ++ ++ prev.type = 'globstar'; ++ prev.output = globstar(opts); ++ prev.value += value; // reset output with globstar ++ ++ state.output += prev.output; ++ state.globstar = true; ++ consume(value); ++ continue; ++ } ++ ++ const token = { ++ type: 'star', ++ value, ++ output: star ++ }; ++ ++ if (opts.bash === true) { ++ token.output = '.*?'; ++ ++ if (prev.type === 'bos' || prev.type === 'slash') { ++ token.output = nodot + token.output; ++ } ++ ++ push(token); ++ continue; ++ } ++ ++ if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) { ++ token.output = value; ++ push(token); ++ continue; ++ } ++ ++ if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') { ++ if (prev.type === 'dot') { ++ state.output += NO_DOT_SLASH; ++ prev.output += NO_DOT_SLASH; ++ } else if (opts.dot === true) { ++ state.output += NO_DOTS_SLASH; ++ prev.output += NO_DOTS_SLASH; ++ } else { ++ state.output += nodot; ++ prev.output += nodot; ++ } ++ ++ if (peek() !== '*') { ++ state.output += ONE_CHAR; ++ prev.output += ONE_CHAR; ++ } ++ } ++ ++ push(token); ++ } ++ ++ while (state.brackets > 0) { ++ if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']')); ++ state.output = utils$3.escapeLast(state.output, '['); ++ decrement('brackets'); ++ } ++ ++ while (state.parens > 0) { ++ if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')')); ++ state.output = utils$3.escapeLast(state.output, '('); ++ decrement('parens'); ++ } ++ ++ while (state.braces > 0) { ++ if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}')); ++ state.output = utils$3.escapeLast(state.output, '{'); ++ decrement('braces'); ++ } ++ ++ if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) { ++ push({ ++ type: 'maybe_slash', ++ value: '', ++ output: `${SLASH_LITERAL}?` ++ }); ++ } // rebuild the output if we had to backtrack at any point ++ ++ ++ if (state.backtrack === true) { ++ state.output = ''; ++ ++ for (const token of state.tokens) { ++ state.output += token.output != null ? token.output : token.value; ++ ++ if (token.suffix) { ++ state.output += token.suffix; ++ } ++ } ++ } ++ ++ return state; ++}; ++/** ++ * Fast paths for creating regular expressions for common glob patterns. ++ * This can significantly speed up processing and has very little downside ++ * impact when none of the fast paths match. ++ */ ++ ++ ++parse$3.fastpaths = (input, options) => { ++ const opts = Object.assign({}, options); ++ const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$3, opts.maxLength) : MAX_LENGTH$3; ++ const len = input.length; ++ ++ if (len > max) { ++ throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`); ++ } ++ ++ input = REPLACEMENTS[input] || input; ++ const win32 = utils$3.isWindows(options); // create constants based on platform, for windows or posix ++ ++ const { ++ DOT_LITERAL, ++ SLASH_LITERAL, ++ ONE_CHAR, ++ DOTS_SLASH, ++ NO_DOT, ++ NO_DOTS, ++ NO_DOTS_SLASH, ++ STAR, ++ START_ANCHOR ++ } = constants$2.globChars(win32); ++ const nodot = opts.dot ? NO_DOTS : NO_DOT; ++ const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT; ++ const capture = opts.capture ? '' : '?:'; ++ const state = { ++ negated: false, ++ prefix: '' ++ }; ++ let star = opts.bash === true ? '.*?' : STAR; ++ ++ if (opts.capture) { ++ star = `(${star})`; ++ } ++ ++ const globstar = opts => { ++ if (opts.noglobstar === true) return star; ++ return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`; ++ }; ++ ++ const create = str => { ++ switch (str) { ++ case '*': ++ return `${nodot}${ONE_CHAR}${star}`; ++ ++ case '.*': ++ return `${DOT_LITERAL}${ONE_CHAR}${star}`; ++ ++ case '*.*': ++ return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`; ++ ++ case '*/*': ++ return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`; ++ ++ case '**': ++ return nodot + globstar(opts); ++ ++ case '**/*': ++ return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`; ++ ++ case '**/*.*': ++ return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`; ++ ++ case '**/.*': ++ return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`; ++ ++ default: ++ { ++ const match = /^(.*?)\.(\w+)$/.exec(str); ++ if (!match) return; ++ const source = create(match[1]); ++ if (!source) return; ++ return source + DOT_LITERAL + match[2]; ++ } ++ } ++ }; ++ ++ const output = utils$3.removePrefix(input, state); ++ let source = create(output); ++ ++ if (source && opts.strictSlashes !== true) { ++ source += `${SLASH_LITERAL}?`; ++ } ++ ++ return source; ++}; ++ ++var parse_1$1 = parse$3; ++ ++const isObject$2 = val => val && typeof val === 'object' && !Array.isArray(val); ++/** ++ * Creates a matcher function from one or more glob patterns. The ++ * returned function takes a string to match as its first argument, ++ * and returns true if the string is a match. The returned matcher ++ * function also takes a boolean as the second argument that, when true, ++ * returns an object with additional information. ++ * ++ * ```js ++ * const picomatch = require('picomatch'); ++ * // picomatch(glob[, options]); ++ * ++ * const isMatch = picomatch('*.!(*a)'); ++ * console.log(isMatch('a.a')); //=> false ++ * console.log(isMatch('a.b')); //=> true ++ * ``` ++ * @name picomatch ++ * @param {String|Array} `globs` One or more glob patterns. ++ * @param {Object=} `options` ++ * @return {Function=} Returns a matcher function. ++ * @api public ++ */ ++ ++ ++const picomatch = (glob, options, returnState = false) => { ++ if (Array.isArray(glob)) { ++ const fns = glob.map(input => picomatch(input, options, returnState)); ++ ++ const arrayMatcher = str => { ++ for (const isMatch of fns) { ++ const state = isMatch(str); ++ if (state) return state; ++ } ++ ++ return false; ++ }; ++ ++ return arrayMatcher; ++ } ++ ++ const isState = isObject$2(glob) && glob.tokens && glob.input; ++ ++ if (glob === '' || typeof glob !== 'string' && !isState) { ++ throw new TypeError('Expected pattern to be a non-empty string'); ++ } ++ ++ const opts = options || {}; ++ const posix = utils$3.isWindows(options); ++ const regex = isState ? picomatch.compileRe(glob, options) : picomatch.makeRe(glob, options, false, true); ++ const state = regex.state; ++ delete regex.state; ++ ++ let isIgnored = () => false; ++ ++ if (opts.ignore) { ++ const ignoreOpts = Object.assign({}, options, { ++ ignore: null, ++ onMatch: null, ++ onResult: null ++ }); ++ isIgnored = picomatch(opts.ignore, ignoreOpts, returnState); ++ } ++ ++ const matcher = (input, returnObject = false) => { ++ const { ++ isMatch, ++ match, ++ output ++ } = picomatch.test(input, regex, options, { ++ glob, ++ posix ++ }); ++ const result = { ++ glob, ++ state, ++ regex, ++ posix, ++ input, ++ output, ++ match, ++ isMatch ++ }; ++ ++ if (typeof opts.onResult === 'function') { ++ opts.onResult(result); ++ } ++ ++ if (isMatch === false) { ++ result.isMatch = false; ++ return returnObject ? result : false; ++ } ++ ++ if (isIgnored(input)) { ++ if (typeof opts.onIgnore === 'function') { ++ opts.onIgnore(result); ++ } ++ ++ result.isMatch = false; ++ return returnObject ? result : false; ++ } ++ ++ if (typeof opts.onMatch === 'function') { ++ opts.onMatch(result); ++ } ++ ++ return returnObject ? result : true; ++ }; ++ ++ if (returnState) { ++ matcher.state = state; ++ } ++ ++ return matcher; ++}; ++/** ++ * Test `input` with the given `regex`. This is used by the main ++ * `picomatch()` function to test the input string. ++ * ++ * ```js ++ * const picomatch = require('picomatch'); ++ * // picomatch.test(input, regex[, options]); ++ * ++ * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/)); ++ * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' } ++ * ``` ++ * @param {String} `input` String to test. ++ * @param {RegExp} `regex` ++ * @return {Object} Returns an object with matching info. ++ * @api public ++ */ ++ ++ ++picomatch.test = (input, regex, options, { ++ glob, ++ posix ++} = {}) => { ++ if (typeof input !== 'string') { ++ throw new TypeError('Expected input to be a string'); ++ } ++ ++ if (input === '') { ++ return { ++ isMatch: false, ++ output: '' ++ }; ++ } ++ ++ const opts = options || {}; ++ const format = opts.format || (posix ? utils$3.toPosixSlashes : null); ++ let match = input === glob; ++ let output = match && format ? format(input) : input; ++ ++ if (match === false) { ++ output = format ? format(input) : input; ++ match = output === glob; ++ } ++ ++ if (match === false || opts.capture === true) { ++ if (opts.matchBase === true || opts.basename === true) { ++ match = picomatch.matchBase(input, regex, options, posix); ++ } else { ++ match = regex.exec(output); ++ } ++ } ++ ++ return { ++ isMatch: Boolean(match), ++ match, ++ output ++ }; ++}; ++/** ++ * Match the basename of a filepath. ++ * ++ * ```js ++ * const picomatch = require('picomatch'); ++ * // picomatch.matchBase(input, glob[, options]); ++ * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true ++ * ``` ++ * @param {String} `input` String to test. ++ * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe). ++ * @return {Boolean} ++ * @api public ++ */ ++ ++ ++picomatch.matchBase = (input, glob, options, posix = utils$3.isWindows(options)) => { ++ const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options); ++ return regex.test(path$1.basename(input)); ++}; ++/** ++ * Returns true if **any** of the given glob `patterns` match the specified `string`. ++ * ++ * ```js ++ * const picomatch = require('picomatch'); ++ * // picomatch.isMatch(string, patterns[, options]); ++ * ++ * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true ++ * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false ++ * ``` ++ * @param {String|Array} str The string to test. ++ * @param {String|Array} patterns One or more glob patterns to use for matching. ++ * @param {Object} [options] See available [options](#options). ++ * @return {Boolean} Returns true if any patterns match `str` ++ * @api public ++ */ ++ ++ ++picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str); ++/** ++ * Parse a glob pattern to create the source string for a regular ++ * expression. ++ * ++ * ```js ++ * const picomatch = require('picomatch'); ++ * const result = picomatch.parse(pattern[, options]); ++ * ``` ++ * @param {String} `pattern` ++ * @param {Object} `options` ++ * @return {Object} Returns an object with useful properties and output to be used as a regex source string. ++ * @api public ++ */ ++ ++ ++picomatch.parse = (pattern, options) => { ++ if (Array.isArray(pattern)) return pattern.map(p => picomatch.parse(p, options)); ++ return parse_1$1(pattern, Object.assign({}, options, { ++ fastpaths: false ++ })); ++}; ++/** ++ * Scan a glob pattern to separate the pattern into segments. ++ * ++ * ```js ++ * const picomatch = require('picomatch'); ++ * // picomatch.scan(input[, options]); ++ * ++ * const result = picomatch.scan('!./foo/*.js'); ++ * console.log(result); ++ * { prefix: '!./', ++ * input: '!./foo/*.js', ++ * start: 3, ++ * base: 'foo', ++ * glob: '*.js', ++ * isBrace: false, ++ * isBracket: false, ++ * isGlob: true, ++ * isExtglob: false, ++ * isGlobstar: false, ++ * negated: true } ++ * ``` ++ * @param {String} `input` Glob pattern to scan. ++ * @param {Object} `options` ++ * @return {Object} Returns an object with ++ * @api public ++ */ ++ ++ ++picomatch.scan = (input, options) => scan_1(input, options); ++/** ++ * Create a regular expression from a glob pattern. ++ * ++ * ```js ++ * const picomatch = require('picomatch'); ++ * // picomatch.makeRe(input[, options]); ++ * ++ * console.log(picomatch.makeRe('*.js')); ++ * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/ ++ * ``` ++ * @param {String} `input` A glob pattern to convert to regex. ++ * @param {Object} `options` ++ * @return {RegExp} Returns a regex created from the given pattern. ++ * @api public ++ */ ++ ++ ++picomatch.compileRe = (parsed, options, returnOutput = false, returnState = false) => { ++ if (returnOutput === true) { ++ return parsed.output; ++ } ++ ++ const opts = options || {}; ++ const prepend = opts.contains ? '' : '^'; ++ const append = opts.contains ? '' : '$'; ++ let source = `${prepend}(?:${parsed.output})${append}`; ++ ++ if (parsed && parsed.negated === true) { ++ source = `^(?!${source}).*$`; ++ } ++ ++ const regex = picomatch.toRegex(source, options); ++ ++ if (returnState === true) { ++ regex.state = parsed; ++ } ++ ++ return regex; ++}; ++ ++picomatch.makeRe = (input, options, returnOutput = false, returnState = false) => { ++ if (!input || typeof input !== 'string') { ++ throw new TypeError('Expected a non-empty string'); ++ } ++ ++ const opts = options || {}; ++ let parsed = { ++ negated: false, ++ fastpaths: true ++ }; ++ let prefix = ''; ++ let output; ++ ++ if (input.startsWith('./')) { ++ input = input.slice(2); ++ prefix = parsed.prefix = './'; ++ } ++ ++ if (opts.fastpaths !== false && (input[0] === '.' || input[0] === '*')) { ++ output = parse_1$1.fastpaths(input, options); ++ } ++ ++ if (output === undefined) { ++ parsed = parse_1$1(input, options); ++ parsed.prefix = prefix + (parsed.prefix || ''); ++ } else { ++ parsed.output = output; ++ } ++ ++ return picomatch.compileRe(parsed, options, returnOutput, returnState); ++}; ++/** ++ * Create a regular expression from the given regex source string. ++ * ++ * ```js ++ * const picomatch = require('picomatch'); ++ * // picomatch.toRegex(source[, options]); ++ * ++ * const { output } = picomatch.parse('*.js'); ++ * console.log(picomatch.toRegex(output)); ++ * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/ ++ * ``` ++ * @param {String} `source` Regular expression source string. ++ * @param {Object} `options` ++ * @return {RegExp} ++ * @api public ++ */ ++ ++ ++picomatch.toRegex = (source, options) => { ++ try { ++ const opts = options || {}; ++ return new RegExp(source, opts.flags || (opts.nocase ? 'i' : '')); ++ } catch (err) { ++ if (options && options.debug === true) throw err; ++ return /$^/; ++ } ++}; ++/** ++ * Picomatch constants. ++ * @return {Object} ++ */ ++ ++ ++picomatch.constants = constants$2; ++/** ++ * Expose "picomatch" ++ */ ++ ++var picomatch_1 = picomatch; ++ ++var picomatch$1 = picomatch_1; ++ ++const isEmptyString = val => typeof val === 'string' && (val === '' || val === './'); ++/** ++ * Returns an array of strings that match one or more glob patterns. ++ * ++ * ```js ++ * const mm = require('micromatch'); ++ * // mm(list, patterns[, options]); ++ * ++ * console.log(mm(['a.js', 'a.txt'], ['*.js'])); ++ * //=> [ 'a.js' ] ++ * ``` ++ * @param {String|Array} list List of strings to match. ++ * @param {String|Array} patterns One or more glob patterns to use for matching. ++ * @param {Object} options See available [options](#options) ++ * @return {Array} Returns an array of matches ++ * @summary false ++ * @api public ++ */ ++ ++ ++const micromatch = (list, patterns, options) => { ++ patterns = [].concat(patterns); ++ list = [].concat(list); ++ let omit = new Set(); ++ let keep = new Set(); ++ let items = new Set(); ++ let negatives = 0; ++ ++ let onResult = state => { ++ items.add(state.output); ++ ++ if (options && options.onResult) { ++ options.onResult(state); ++ } ++ }; ++ ++ for (let i = 0; i < patterns.length; i++) { ++ let isMatch = picomatch$1(String(patterns[i]), Object.assign({}, options, { ++ onResult ++ }), true); ++ let negated = isMatch.state.negated || isMatch.state.negatedExtglob; ++ if (negated) negatives++; ++ ++ for (let item of list) { ++ let matched = isMatch(item, true); ++ let match = negated ? !matched.isMatch : matched.isMatch; ++ if (!match) continue; ++ ++ if (negated) { ++ omit.add(matched.output); ++ } else { ++ omit.delete(matched.output); ++ keep.add(matched.output); ++ } ++ } ++ } ++ ++ let result = negatives === patterns.length ? [...items] : [...keep]; ++ let matches = result.filter(item => !omit.has(item)); ++ ++ if (options && matches.length === 0) { ++ if (options.failglob === true) { ++ throw new Error(`No matches found for "${patterns.join(', ')}"`); ++ } ++ ++ if (options.nonull === true || options.nullglob === true) { ++ return options.unescape ? patterns.map(p => p.replace(/\\/g, '')) : patterns; ++ } ++ } ++ ++ return matches; ++}; ++/** ++ * Backwards compatibility ++ */ ++ ++ ++micromatch.match = micromatch; ++/** ++ * Returns a matcher function from the given glob `pattern` and `options`. ++ * The returned function takes a string to match as its only argument and returns ++ * true if the string is a match. ++ * ++ * ```js ++ * const mm = require('micromatch'); ++ * // mm.matcher(pattern[, options]); ++ * ++ * const isMatch = mm.matcher('*.!(*a)'); ++ * console.log(isMatch('a.a')); //=> false ++ * console.log(isMatch('a.b')); //=> true ++ * ``` ++ * @param {String} `pattern` Glob pattern ++ * @param {Object} `options` ++ * @return {Function} Returns a matcher function. ++ * @api public ++ */ ++ ++micromatch.matcher = (pattern, options) => picomatch$1(pattern, options); ++/** ++ * Returns true if **any** of the given glob `patterns` match the specified `string`. ++ * ++ * ```js ++ * const mm = require('micromatch'); ++ * // mm.isMatch(string, patterns[, options]); ++ * ++ * console.log(mm.isMatch('a.a', ['b.*', '*.a'])); //=> true ++ * console.log(mm.isMatch('a.a', 'b.*')); //=> false ++ * ``` ++ * @param {String} str The string to test. ++ * @param {String|Array} patterns One or more glob patterns to use for matching. ++ * @param {Object} [options] See available [options](#options). ++ * @return {Boolean} Returns true if any patterns match `str` ++ * @api public ++ */ ++ ++ ++micromatch.isMatch = (str, patterns, options) => picomatch$1(patterns, options)(str); ++/** ++ * Backwards compatibility ++ */ ++ ++ ++micromatch.any = micromatch.isMatch; ++/** ++ * Returns a list of strings that _**do not match any**_ of the given `patterns`. ++ * ++ * ```js ++ * const mm = require('micromatch'); ++ * // mm.not(list, patterns[, options]); ++ * ++ * console.log(mm.not(['a.a', 'b.b', 'c.c'], '*.a')); ++ * //=> ['b.b', 'c.c'] ++ * ``` ++ * @param {Array} `list` Array of strings to match. ++ * @param {String|Array} `patterns` One or more glob pattern to use for matching. ++ * @param {Object} `options` See available [options](#options) for changing how matches are performed ++ * @return {Array} Returns an array of strings that **do not match** the given patterns. ++ * @api public ++ */ ++ ++micromatch.not = (list, patterns, options = {}) => { ++ patterns = [].concat(patterns).map(String); ++ let result = new Set(); ++ let items = []; ++ ++ let onResult = state => { ++ if (options.onResult) options.onResult(state); ++ items.push(state.output); ++ }; ++ ++ let matches = micromatch(list, patterns, Object.assign({}, options, { ++ onResult ++ })); ++ ++ for (let item of items) { ++ if (!matches.includes(item)) { ++ result.add(item); ++ } ++ } ++ ++ return [...result]; ++}; ++/** ++ * Returns true if the given `string` contains the given pattern. Similar ++ * to [.isMatch](#isMatch) but the pattern can match any part of the string. ++ * ++ * ```js ++ * var mm = require('micromatch'); ++ * // mm.contains(string, pattern[, options]); ++ * ++ * console.log(mm.contains('aa/bb/cc', '*b')); ++ * //=> true ++ * console.log(mm.contains('aa/bb/cc', '*d')); ++ * //=> false ++ * ``` ++ * @param {String} `str` The string to match. ++ * @param {String|Array} `patterns` Glob pattern to use for matching. ++ * @param {Object} `options` See available [options](#options) for changing how matches are performed ++ * @return {Boolean} Returns true if the patter matches any part of `str`. ++ * @api public ++ */ ++ ++ ++micromatch.contains = (str, pattern, options) => { ++ if (typeof str !== 'string') { ++ throw new TypeError(`Expected a string: "${util$3.inspect(str)}"`); ++ } ++ ++ if (Array.isArray(pattern)) { ++ return pattern.some(p => micromatch.contains(str, p, options)); ++ } ++ ++ if (typeof pattern === 'string') { ++ if (isEmptyString(str) || isEmptyString(pattern)) { ++ return false; ++ } ++ ++ if (str.includes(pattern) || str.startsWith('./') && str.slice(2).includes(pattern)) { ++ return true; ++ } ++ } ++ ++ return micromatch.isMatch(str, pattern, Object.assign({}, options, { ++ contains: true ++ })); ++}; ++/** ++ * Filter the keys of the given object with the given `glob` pattern ++ * and `options`. Does not attempt to match nested keys. If you need this feature, ++ * use [glob-object][] instead. ++ * ++ * ```js ++ * const mm = require('micromatch'); ++ * // mm.matchKeys(object, patterns[, options]); ++ * ++ * const obj = { aa: 'a', ab: 'b', ac: 'c' }; ++ * console.log(mm.matchKeys(obj, '*b')); ++ * //=> { ab: 'b' } ++ * ``` ++ * @param {Object} `object` The object with keys to filter. ++ * @param {String|Array} `patterns` One or more glob patterns to use for matching. ++ * @param {Object} `options` See available [options](#options) for changing how matches are performed ++ * @return {Object} Returns an object with only keys that match the given patterns. ++ * @api public ++ */ ++ ++ ++micromatch.matchKeys = (obj, patterns, options) => { ++ if (!utils$3.isObject(obj)) { ++ throw new TypeError('Expected the first argument to be an object'); ++ } ++ ++ let keys = micromatch(Object.keys(obj), patterns, options); ++ let res = {}; ++ ++ for (let key of keys) res[key] = obj[key]; ++ ++ return res; ++}; ++/** ++ * Returns true if some of the strings in the given `list` match any of the given glob `patterns`. ++ * ++ * ```js ++ * const mm = require('micromatch'); ++ * // mm.some(list, patterns[, options]); ++ * ++ * console.log(mm.some(['foo.js', 'bar.js'], ['*.js', '!foo.js'])); ++ * // true ++ * console.log(mm.some(['foo.js'], ['*.js', '!foo.js'])); ++ * // false ++ * ``` ++ * @param {String|Array} `list` The string or array of strings to test. Returns as soon as the first match is found. ++ * @param {String|Array} `patterns` One or more glob patterns to use for matching. ++ * @param {Object} `options` See available [options](#options) for changing how matches are performed ++ * @return {Boolean} Returns true if any patterns match `str` ++ * @api public ++ */ ++ ++ ++micromatch.some = (list, patterns, options) => { ++ let items = [].concat(list); ++ ++ for (let pattern of [].concat(patterns)) { ++ let isMatch = picomatch$1(String(pattern), options); ++ ++ if (items.some(item => isMatch(item))) { ++ return true; ++ } ++ } ++ ++ return false; ++}; ++/** ++ * Returns true if every string in the given `list` matches ++ * any of the given glob `patterns`. ++ * ++ * ```js ++ * const mm = require('micromatch'); ++ * // mm.every(list, patterns[, options]); ++ * ++ * console.log(mm.every('foo.js', ['foo.js'])); ++ * // true ++ * console.log(mm.every(['foo.js', 'bar.js'], ['*.js'])); ++ * // true ++ * console.log(mm.every(['foo.js', 'bar.js'], ['*.js', '!foo.js'])); ++ * // false ++ * console.log(mm.every(['foo.js'], ['*.js', '!foo.js'])); ++ * // false ++ * ``` ++ * @param {String|Array} `list` The string or array of strings to test. ++ * @param {String|Array} `patterns` One or more glob patterns to use for matching. ++ * @param {Object} `options` See available [options](#options) for changing how matches are performed ++ * @return {Boolean} Returns true if any patterns match `str` ++ * @api public ++ */ ++ ++ ++micromatch.every = (list, patterns, options) => { ++ let items = [].concat(list); ++ ++ for (let pattern of [].concat(patterns)) { ++ let isMatch = picomatch$1(String(pattern), options); ++ ++ if (!items.every(item => isMatch(item))) { ++ return false; ++ } ++ } ++ ++ return true; ++}; ++/** ++ * Returns true if **all** of the given `patterns` match ++ * the specified string. ++ * ++ * ```js ++ * const mm = require('micromatch'); ++ * // mm.all(string, patterns[, options]); ++ * ++ * console.log(mm.all('foo.js', ['foo.js'])); ++ * // true ++ * ++ * console.log(mm.all('foo.js', ['*.js', '!foo.js'])); ++ * // false ++ * ++ * console.log(mm.all('foo.js', ['*.js', 'foo.js'])); ++ * // true ++ * ++ * console.log(mm.all('foo.js', ['*.js', 'f*', '*o*', '*o.js'])); ++ * // true ++ * ``` ++ * @param {String|Array} `str` The string to test. ++ * @param {String|Array} `patterns` One or more glob patterns to use for matching. ++ * @param {Object} `options` See available [options](#options) for changing how matches are performed ++ * @return {Boolean} Returns true if any patterns match `str` ++ * @api public ++ */ ++ ++ ++micromatch.all = (str, patterns, options) => { ++ if (typeof str !== 'string') { ++ throw new TypeError(`Expected a string: "${util$3.inspect(str)}"`); ++ } ++ ++ return [].concat(patterns).every(p => picomatch$1(p, options)(str)); ++}; ++/** ++ * Returns an array of matches captured by `pattern` in `string, or `null` if the pattern did not match. ++ * ++ * ```js ++ * const mm = require('micromatch'); ++ * // mm.capture(pattern, string[, options]); ++ * ++ * console.log(mm.capture('test/*.js', 'test/foo.js')); ++ * //=> ['foo'] ++ * console.log(mm.capture('test/*.js', 'foo/bar.css')); ++ * //=> null ++ * ``` ++ * @param {String} `glob` Glob pattern to use for matching. ++ * @param {String} `input` String to match ++ * @param {Object} `options` See available [options](#options) for changing how matches are performed ++ * @return {Boolean} Returns an array of captures if the input matches the glob pattern, otherwise `null`. ++ * @api public ++ */ ++ ++ ++micromatch.capture = (glob, input, options) => { ++ let posix = utils$3.isWindows(options); ++ let regex = picomatch$1.makeRe(String(glob), Object.assign({}, options, { ++ capture: true ++ })); ++ let match = regex.exec(posix ? utils$3.toPosixSlashes(input) : input); ++ ++ if (match) { ++ return match.slice(1).map(v => v === void 0 ? '' : v); ++ } ++}; ++/** ++ * Create a regular expression from the given glob `pattern`. ++ * ++ * ```js ++ * const mm = require('micromatch'); ++ * // mm.makeRe(pattern[, options]); ++ * ++ * console.log(mm.makeRe('*.js')); ++ * //=> /^(?:(\.[\\\/])?(?!\.)(?=.)[^\/]*?\.js)$/ ++ * ``` ++ * @param {String} `pattern` A glob pattern to convert to regex. ++ * @param {Object} `options` ++ * @return {RegExp} Returns a regex created from the given pattern. ++ * @api public ++ */ ++ ++ ++micromatch.makeRe = (...args) => picomatch$1.makeRe(...args); ++/** ++ * Scan a glob pattern to separate the pattern into segments. Used ++ * by the [split](#split) method. ++ * ++ * ```js ++ * const mm = require('micromatch'); ++ * const state = mm.scan(pattern[, options]); ++ * ``` ++ * @param {String} `pattern` ++ * @param {Object} `options` ++ * @return {Object} Returns an object with ++ * @api public ++ */ ++ ++ ++micromatch.scan = (...args) => picomatch$1.scan(...args); ++/** ++ * Parse a glob pattern to create the source string for a regular ++ * expression. ++ * ++ * ```js ++ * const mm = require('micromatch'); ++ * const state = mm(pattern[, options]); ++ * ``` ++ * @param {String} `glob` ++ * @param {Object} `options` ++ * @return {Object} Returns an object with useful properties and output to be used as regex source string. ++ * @api public ++ */ ++ ++ ++micromatch.parse = (patterns, options) => { ++ let res = []; ++ ++ for (let pattern of [].concat(patterns || [])) { ++ for (let str of braces_1(String(pattern), options)) { ++ res.push(picomatch$1.parse(str, options)); ++ } ++ } ++ ++ return res; ++}; ++/** ++ * Process the given brace `pattern`. ++ * ++ * ```js ++ * const { braces } = require('micromatch'); ++ * console.log(braces('foo/{a,b,c}/bar')); ++ * //=> [ 'foo/(a|b|c)/bar' ] ++ * ++ * console.log(braces('foo/{a,b,c}/bar', { expand: true })); ++ * //=> [ 'foo/a/bar', 'foo/b/bar', 'foo/c/bar' ] ++ * ``` ++ * @param {String} `pattern` String with brace pattern to process. ++ * @param {Object} `options` Any [options](#options) to change how expansion is performed. See the [braces][] library for all available options. ++ * @return {Array} ++ * @api public ++ */ ++ ++ ++micromatch.braces = (pattern, options) => { ++ if (typeof pattern !== 'string') throw new TypeError('Expected a string'); ++ ++ if (options && options.nobrace === true || !/\{.*\}/.test(pattern)) { ++ return [pattern]; ++ } ++ ++ return braces_1(pattern, options); ++}; ++/** ++ * Expand braces ++ */ ++ ++ ++micromatch.braceExpand = (pattern, options) => { ++ if (typeof pattern !== 'string') throw new TypeError('Expected a string'); ++ return micromatch.braces(pattern, Object.assign({}, options, { ++ expand: true ++ })); ++}; ++/** ++ * Expose micromatch ++ */ ++ ++ ++var micromatch_1 = micromatch; ++ ++var pattern = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ const GLOBSTAR = '**'; ++ const ESCAPE_SYMBOL = '\\'; ++ const COMMON_GLOB_SYMBOLS_RE = /[*?]|^!/; ++ const REGEX_CHARACTER_CLASS_SYMBOLS_RE = /\[.*]/; ++ const REGEX_GROUP_SYMBOLS_RE = /(?:^|[^!*+?@])\(.*\|.*\)/; ++ const GLOB_EXTENSION_SYMBOLS_RE = /[!*+?@]\(.*\)/; ++ const BRACE_EXPANSIONS_SYMBOLS_RE = /{.*(?:,|\.\.).*}/; ++ ++ function isStaticPattern(pattern, options = {}) { ++ return !isDynamicPattern(pattern, options); ++ } ++ ++ exports.isStaticPattern = isStaticPattern; ++ ++ function isDynamicPattern(pattern, options = {}) { ++ /** ++ * When the `caseSensitiveMatch` option is disabled, all patterns must be marked as dynamic, because we cannot check ++ * filepath directly (without read directory). ++ */ ++ if (options.caseSensitiveMatch === false || pattern.includes(ESCAPE_SYMBOL)) { ++ return true; ++ } ++ ++ if (COMMON_GLOB_SYMBOLS_RE.test(pattern) || REGEX_CHARACTER_CLASS_SYMBOLS_RE.test(pattern) || REGEX_GROUP_SYMBOLS_RE.test(pattern)) { ++ return true; ++ } ++ ++ if (options.extglob !== false && GLOB_EXTENSION_SYMBOLS_RE.test(pattern)) { ++ return true; ++ } ++ ++ if (options.braceExpansion !== false && BRACE_EXPANSIONS_SYMBOLS_RE.test(pattern)) { ++ return true; ++ } ++ ++ return false; ++ } ++ ++ exports.isDynamicPattern = isDynamicPattern; ++ ++ function convertToPositivePattern(pattern) { ++ return isNegativePattern(pattern) ? pattern.slice(1) : pattern; ++ } ++ ++ exports.convertToPositivePattern = convertToPositivePattern; ++ ++ function convertToNegativePattern(pattern) { ++ return '!' + pattern; ++ } ++ ++ exports.convertToNegativePattern = convertToNegativePattern; ++ ++ function isNegativePattern(pattern) { ++ return pattern.startsWith('!') && pattern[1] !== '('; ++ } ++ ++ exports.isNegativePattern = isNegativePattern; ++ ++ function isPositivePattern(pattern) { ++ return !isNegativePattern(pattern); ++ } ++ ++ exports.isPositivePattern = isPositivePattern; ++ ++ function getNegativePatterns(patterns) { ++ return patterns.filter(isNegativePattern); ++ } ++ ++ exports.getNegativePatterns = getNegativePatterns; ++ ++ function getPositivePatterns(patterns) { ++ return patterns.filter(isPositivePattern); ++ } ++ ++ exports.getPositivePatterns = getPositivePatterns; ++ ++ function getBaseDirectory(pattern) { ++ return globParent(pattern, { ++ flipBackslashes: false ++ }); ++ } ++ ++ exports.getBaseDirectory = getBaseDirectory; ++ ++ function hasGlobStar(pattern) { ++ return pattern.includes(GLOBSTAR); ++ } ++ ++ exports.hasGlobStar = hasGlobStar; ++ ++ function endsWithSlashGlobStar(pattern) { ++ return pattern.endsWith('/' + GLOBSTAR); ++ } ++ ++ exports.endsWithSlashGlobStar = endsWithSlashGlobStar; ++ ++ function isAffectDepthOfReadingPattern(pattern) { ++ const basename = path$1.basename(pattern); ++ return endsWithSlashGlobStar(pattern) || isStaticPattern(basename); ++ } ++ ++ exports.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern; ++ ++ function expandPatternsWithBraceExpansion(patterns) { ++ return patterns.reduce((collection, pattern) => { ++ return collection.concat(expandBraceExpansion(pattern)); ++ }, []); ++ } ++ ++ exports.expandPatternsWithBraceExpansion = expandPatternsWithBraceExpansion; ++ ++ function expandBraceExpansion(pattern) { ++ return micromatch_1.braces(pattern, { ++ expand: true, ++ nodupes: true ++ }); ++ } ++ ++ exports.expandBraceExpansion = expandBraceExpansion; ++ ++ function getPatternParts(pattern, options) { ++ const info = picomatch$1.scan(pattern, Object.assign(Object.assign({}, options), { ++ parts: true ++ })); // See micromatch/picomatch#58 for more details ++ ++ if (info.parts.length === 0) { ++ return [pattern]; ++ } ++ ++ return info.parts; ++ } ++ ++ exports.getPatternParts = getPatternParts; ++ ++ function makeRe(pattern, options) { ++ return micromatch_1.makeRe(pattern, options); ++ } ++ ++ exports.makeRe = makeRe; ++ ++ function convertPatternsToRe(patterns, options) { ++ return patterns.map(pattern => makeRe(pattern, options)); ++ } ++ ++ exports.convertPatternsToRe = convertPatternsToRe; ++ ++ function matchAny(entry, patternsRe) { ++ return patternsRe.some(patternRe => patternRe.test(entry)); ++ } ++ ++ exports.matchAny = matchAny; ++}); ++unwrapExports(pattern); ++var pattern_1 = pattern.isStaticPattern; ++var pattern_2 = pattern.isDynamicPattern; ++var pattern_3 = pattern.convertToPositivePattern; ++var pattern_4 = pattern.convertToNegativePattern; ++var pattern_5 = pattern.isNegativePattern; ++var pattern_6 = pattern.isPositivePattern; ++var pattern_7 = pattern.getNegativePatterns; ++var pattern_8 = pattern.getPositivePatterns; ++var pattern_9 = pattern.getBaseDirectory; ++var pattern_10 = pattern.hasGlobStar; ++var pattern_11 = pattern.endsWithSlashGlobStar; ++var pattern_12 = pattern.isAffectDepthOfReadingPattern; ++var pattern_13 = pattern.expandPatternsWithBraceExpansion; ++var pattern_14 = pattern.expandBraceExpansion; ++var pattern_15 = pattern.getPatternParts; ++var pattern_16 = pattern.makeRe; ++var pattern_17 = pattern.convertPatternsToRe; ++var pattern_18 = pattern.matchAny; ++ ++var stream = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ function merge(streams) { ++ const mergedStream = merge2_1(streams); ++ streams.forEach(stream => { ++ stream.once('error', error => mergedStream.emit('error', error)); ++ }); ++ mergedStream.once('close', () => propagateCloseEventToSources(streams)); ++ mergedStream.once('end', () => propagateCloseEventToSources(streams)); ++ return mergedStream; ++ } ++ ++ exports.merge = merge; ++ ++ function propagateCloseEventToSources(streams) { ++ streams.forEach(stream => stream.emit('close')); ++ } ++}); ++unwrapExports(stream); ++var stream_1 = stream.merge; ++ ++var string$1 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ function isString(input) { ++ return typeof input === 'string'; ++ } ++ ++ exports.isString = isString; ++ ++ function isEmpty(input) { ++ return input === ''; ++ } ++ ++ exports.isEmpty = isEmpty; ++}); ++unwrapExports(string$1); ++var string_1$1 = string$1.isString; ++var string_2 = string$1.isEmpty; ++ ++var utils$4 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ exports.array = array$2; ++ exports.errno = errno; ++ exports.fs = fs; ++ exports.path = path_1; ++ exports.pattern = pattern; ++ exports.stream = stream; ++ exports.string = string$1; ++}); ++unwrapExports(utils$4); ++var utils_1$4 = utils$4.array; ++var utils_2$4 = utils$4.errno; ++var utils_3$4 = utils$4.fs; ++var utils_4$3 = utils$4.path; ++var utils_5$3 = utils$4.pattern; ++var utils_6$3 = utils$4.stream; ++var utils_7$3 = utils$4.string; ++ ++var tasks = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ function generate(patterns, settings) { ++ const positivePatterns = getPositivePatterns(patterns); ++ const negativePatterns = getNegativePatternsAsPositive(patterns, settings.ignore); ++ const staticPatterns = positivePatterns.filter(pattern => utils$4.pattern.isStaticPattern(pattern, settings)); ++ const dynamicPatterns = positivePatterns.filter(pattern => utils$4.pattern.isDynamicPattern(pattern, settings)); ++ const staticTasks = convertPatternsToTasks(staticPatterns, negativePatterns, ++ /* dynamic */ ++ false); ++ const dynamicTasks = convertPatternsToTasks(dynamicPatterns, negativePatterns, ++ /* dynamic */ ++ true); ++ return staticTasks.concat(dynamicTasks); ++ } ++ ++ exports.generate = generate; ++ ++ function convertPatternsToTasks(positive, negative, dynamic) { ++ const positivePatternsGroup = groupPatternsByBaseDirectory(positive); // When we have a global group – there is no reason to divide the patterns into independent tasks. ++ // In this case, the global task covers the rest. ++ ++ if ('.' in positivePatternsGroup) { ++ const task = convertPatternGroupToTask('.', positive, negative, dynamic); ++ return [task]; ++ } ++ ++ return convertPatternGroupsToTasks(positivePatternsGroup, negative, dynamic); ++ } ++ ++ exports.convertPatternsToTasks = convertPatternsToTasks; ++ ++ function getPositivePatterns(patterns) { ++ return utils$4.pattern.getPositivePatterns(patterns); ++ } ++ ++ exports.getPositivePatterns = getPositivePatterns; ++ ++ function getNegativePatternsAsPositive(patterns, ignore) { ++ const negative = utils$4.pattern.getNegativePatterns(patterns).concat(ignore); ++ const positive = negative.map(utils$4.pattern.convertToPositivePattern); ++ return positive; ++ } ++ ++ exports.getNegativePatternsAsPositive = getNegativePatternsAsPositive; ++ ++ function groupPatternsByBaseDirectory(patterns) { ++ const group = {}; ++ return patterns.reduce((collection, pattern) => { ++ const base = utils$4.pattern.getBaseDirectory(pattern); ++ ++ if (base in collection) { ++ collection[base].push(pattern); ++ } else { ++ collection[base] = [pattern]; ++ } ++ ++ return collection; ++ }, group); ++ } ++ ++ exports.groupPatternsByBaseDirectory = groupPatternsByBaseDirectory; ++ ++ function convertPatternGroupsToTasks(positive, negative, dynamic) { ++ return Object.keys(positive).map(base => { ++ return convertPatternGroupToTask(base, positive[base], negative, dynamic); ++ }); ++ } ++ ++ exports.convertPatternGroupsToTasks = convertPatternGroupsToTasks; ++ ++ function convertPatternGroupToTask(base, positive, negative, dynamic) { ++ return { ++ dynamic, ++ positive, ++ negative, ++ base, ++ patterns: [].concat(positive, negative.map(utils$4.pattern.convertToNegativePattern)) ++ }; ++ } ++ ++ exports.convertPatternGroupToTask = convertPatternGroupToTask; ++}); ++unwrapExports(tasks); ++var tasks_1 = tasks.generate; ++var tasks_2 = tasks.convertPatternsToTasks; ++var tasks_3 = tasks.getPositivePatterns; ++var tasks_4 = tasks.getNegativePatternsAsPositive; ++var tasks_5 = tasks.groupPatternsByBaseDirectory; ++var tasks_6 = tasks.convertPatternGroupsToTasks; ++var tasks_7 = tasks.convertPatternGroupToTask; ++ ++var async = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ function read(path, settings, callback) { ++ settings.fs.lstat(path, (lstatError, lstat) => { ++ if (lstatError !== null) { ++ return callFailureCallback(callback, lstatError); ++ } ++ ++ if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) { ++ return callSuccessCallback(callback, lstat); ++ } ++ ++ settings.fs.stat(path, (statError, stat) => { ++ if (statError !== null) { ++ if (settings.throwErrorOnBrokenSymbolicLink) { ++ return callFailureCallback(callback, statError); ++ } ++ ++ return callSuccessCallback(callback, lstat); ++ } ++ ++ if (settings.markSymbolicLink) { ++ stat.isSymbolicLink = () => true; ++ } ++ ++ callSuccessCallback(callback, stat); ++ }); ++ }); ++ } ++ ++ exports.read = read; ++ ++ function callFailureCallback(callback, error) { ++ callback(error); ++ } ++ ++ function callSuccessCallback(callback, result) { ++ callback(null, result); ++ } ++}); ++unwrapExports(async); ++var async_1 = async.read; ++ ++var sync = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ function read(path, settings) { ++ const lstat = settings.fs.lstatSync(path); ++ ++ if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) { ++ return lstat; ++ } ++ ++ try { ++ const stat = settings.fs.statSync(path); ++ ++ if (settings.markSymbolicLink) { ++ stat.isSymbolicLink = () => true; ++ } ++ ++ return stat; ++ } catch (error) { ++ if (!settings.throwErrorOnBrokenSymbolicLink) { ++ return lstat; ++ } ++ ++ throw error; ++ } ++ } ++ ++ exports.read = read; ++}); ++unwrapExports(sync); ++var sync_1 = sync.read; ++ ++var fs_1$1 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ exports.FILE_SYSTEM_ADAPTER = { ++ lstat: fs$2.lstat, ++ stat: fs$2.stat, ++ lstatSync: fs$2.lstatSync, ++ statSync: fs$2.statSync ++ }; ++ ++ function createFileSystemAdapter(fsMethods) { ++ if (fsMethods === undefined) { ++ return exports.FILE_SYSTEM_ADAPTER; ++ } ++ ++ return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods); ++ } ++ ++ exports.createFileSystemAdapter = createFileSystemAdapter; ++}); ++unwrapExports(fs_1$1); ++var fs_2 = fs_1$1.FILE_SYSTEM_ADAPTER; ++var fs_3 = fs_1$1.createFileSystemAdapter; ++ ++var settings = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class Settings { ++ constructor(_options = {}) { ++ this._options = _options; ++ this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true); ++ this.fs = fs_1$1.createFileSystemAdapter(this._options.fs); ++ this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false); ++ this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true); ++ } ++ ++ _getValue(option, value) { ++ return option === undefined ? value : option; ++ } ++ ++ } ++ ++ exports.default = Settings; ++}); ++unwrapExports(settings); ++ ++var out = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ exports.Settings = settings.default; ++ ++ function stat(path, optionsOrSettingsOrCallback, callback) { ++ if (typeof optionsOrSettingsOrCallback === 'function') { ++ return async.read(path, getSettings(), optionsOrSettingsOrCallback); ++ } ++ ++ async.read(path, getSettings(optionsOrSettingsOrCallback), callback); ++ } ++ ++ exports.stat = stat; ++ ++ function statSync(path, optionsOrSettings) { ++ const settings = getSettings(optionsOrSettings); ++ return sync.read(path, settings); ++ } ++ ++ exports.statSync = statSync; ++ ++ function getSettings(settingsOrOptions = {}) { ++ if (settingsOrOptions instanceof settings.default) { ++ return settingsOrOptions; ++ } ++ ++ return new settings.default(settingsOrOptions); ++ } ++}); ++unwrapExports(out); ++var out_1 = out.Settings; ++var out_2 = out.stat; ++var out_3 = out.statSync; ++ ++var runParallel_1 = runParallel; ++ ++function runParallel(tasks, cb) { ++ var results, pending, keys; ++ var isSync = true; ++ ++ if (Array.isArray(tasks)) { ++ results = []; ++ pending = tasks.length; ++ } else { ++ keys = Object.keys(tasks); ++ results = {}; ++ pending = keys.length; ++ } ++ ++ function done(err) { ++ function end() { ++ if (cb) cb(err, results); ++ cb = null; ++ } ++ ++ if (isSync) process.nextTick(end);else end(); ++ } ++ ++ function each(i, err, result) { ++ results[i] = result; ++ ++ if (--pending === 0 || err) { ++ done(err); ++ } ++ } ++ ++ if (!pending) { ++ // empty ++ done(null); ++ } else if (keys) { ++ // object ++ keys.forEach(function (key) { ++ tasks[key](function (err, result) { ++ each(key, err, result); ++ }); ++ }); ++ } else { ++ // array ++ tasks.forEach(function (task, i) { ++ task(function (err, result) { ++ each(i, err, result); ++ }); ++ }); ++ } ++ ++ isSync = false; ++} ++ ++var constants$3 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ const NODE_PROCESS_VERSION_PARTS = process.versions.node.split('.'); ++ const MAJOR_VERSION = parseInt(NODE_PROCESS_VERSION_PARTS[0], 10); ++ const MINOR_VERSION = parseInt(NODE_PROCESS_VERSION_PARTS[1], 10); ++ const SUPPORTED_MAJOR_VERSION = 10; ++ const SUPPORTED_MINOR_VERSION = 10; ++ const IS_MATCHED_BY_MAJOR = MAJOR_VERSION > SUPPORTED_MAJOR_VERSION; ++ const IS_MATCHED_BY_MAJOR_AND_MINOR = MAJOR_VERSION === SUPPORTED_MAJOR_VERSION && MINOR_VERSION >= SUPPORTED_MINOR_VERSION; ++ /** ++ * IS `true` for Node.js 10.10 and greater. ++ */ ++ ++ exports.IS_SUPPORT_READDIR_WITH_FILE_TYPES = IS_MATCHED_BY_MAJOR || IS_MATCHED_BY_MAJOR_AND_MINOR; ++}); ++unwrapExports(constants$3); ++var constants_1 = constants$3.IS_SUPPORT_READDIR_WITH_FILE_TYPES; ++ ++var fs$1 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class DirentFromStats { ++ constructor(name, stats) { ++ this.name = name; ++ this.isBlockDevice = stats.isBlockDevice.bind(stats); ++ this.isCharacterDevice = stats.isCharacterDevice.bind(stats); ++ this.isDirectory = stats.isDirectory.bind(stats); ++ this.isFIFO = stats.isFIFO.bind(stats); ++ this.isFile = stats.isFile.bind(stats); ++ this.isSocket = stats.isSocket.bind(stats); ++ this.isSymbolicLink = stats.isSymbolicLink.bind(stats); ++ } ++ ++ } ++ ++ function createDirentFromStats(name, stats) { ++ return new DirentFromStats(name, stats); ++ } ++ ++ exports.createDirentFromStats = createDirentFromStats; ++}); ++unwrapExports(fs$1); ++var fs_1$2 = fs$1.createDirentFromStats; ++ ++var utils$5 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ exports.fs = fs$1; ++}); ++unwrapExports(utils$5); ++var utils_1$5 = utils$5.fs; ++ ++var async$1 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ function read(directory, settings, callback) { ++ if (!settings.stats && constants$3.IS_SUPPORT_READDIR_WITH_FILE_TYPES) { ++ return readdirWithFileTypes(directory, settings, callback); ++ } ++ ++ return readdir(directory, settings, callback); ++ } ++ ++ exports.read = read; ++ ++ function readdirWithFileTypes(directory, settings, callback) { ++ settings.fs.readdir(directory, { ++ withFileTypes: true ++ }, (readdirError, dirents) => { ++ if (readdirError !== null) { ++ return callFailureCallback(callback, readdirError); ++ } ++ ++ const entries = dirents.map(dirent => ({ ++ dirent, ++ name: dirent.name, ++ path: `${directory}${settings.pathSegmentSeparator}${dirent.name}` ++ })); ++ ++ if (!settings.followSymbolicLinks) { ++ return callSuccessCallback(callback, entries); ++ } ++ ++ const tasks = entries.map(entry => makeRplTaskEntry(entry, settings)); ++ runParallel_1(tasks, (rplError, rplEntries) => { ++ if (rplError !== null) { ++ return callFailureCallback(callback, rplError); ++ } ++ ++ callSuccessCallback(callback, rplEntries); ++ }); ++ }); ++ } ++ ++ exports.readdirWithFileTypes = readdirWithFileTypes; ++ ++ function makeRplTaskEntry(entry, settings) { ++ return done => { ++ if (!entry.dirent.isSymbolicLink()) { ++ return done(null, entry); ++ } ++ ++ settings.fs.stat(entry.path, (statError, stats) => { ++ if (statError !== null) { ++ if (settings.throwErrorOnBrokenSymbolicLink) { ++ return done(statError); ++ } ++ ++ return done(null, entry); ++ } ++ ++ entry.dirent = utils$5.fs.createDirentFromStats(entry.name, stats); ++ return done(null, entry); ++ }); ++ }; ++ } ++ ++ function readdir(directory, settings, callback) { ++ settings.fs.readdir(directory, (readdirError, names) => { ++ if (readdirError !== null) { ++ return callFailureCallback(callback, readdirError); ++ } ++ ++ const filepaths = names.map(name => `${directory}${settings.pathSegmentSeparator}${name}`); ++ const tasks = filepaths.map(filepath => { ++ return done => out.stat(filepath, settings.fsStatSettings, done); ++ }); ++ runParallel_1(tasks, (rplError, results) => { ++ if (rplError !== null) { ++ return callFailureCallback(callback, rplError); ++ } ++ ++ const entries = []; ++ names.forEach((name, index) => { ++ const stats = results[index]; ++ const entry = { ++ name, ++ path: filepaths[index], ++ dirent: utils$5.fs.createDirentFromStats(name, stats) ++ }; ++ ++ if (settings.stats) { ++ entry.stats = stats; ++ } ++ ++ entries.push(entry); ++ }); ++ callSuccessCallback(callback, entries); ++ }); ++ }); ++ } ++ ++ exports.readdir = readdir; ++ ++ function callFailureCallback(callback, error) { ++ callback(error); ++ } ++ ++ function callSuccessCallback(callback, result) { ++ callback(null, result); ++ } ++}); ++unwrapExports(async$1); ++var async_1$1 = async$1.read; ++var async_2 = async$1.readdirWithFileTypes; ++var async_3 = async$1.readdir; ++ ++var sync$1 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ function read(directory, settings) { ++ if (!settings.stats && constants$3.IS_SUPPORT_READDIR_WITH_FILE_TYPES) { ++ return readdirWithFileTypes(directory, settings); ++ } ++ ++ return readdir(directory, settings); ++ } ++ ++ exports.read = read; ++ ++ function readdirWithFileTypes(directory, settings) { ++ const dirents = settings.fs.readdirSync(directory, { ++ withFileTypes: true ++ }); ++ return dirents.map(dirent => { ++ const entry = { ++ dirent, ++ name: dirent.name, ++ path: `${directory}${settings.pathSegmentSeparator}${dirent.name}` ++ }; ++ ++ if (entry.dirent.isSymbolicLink() && settings.followSymbolicLinks) { ++ try { ++ const stats = settings.fs.statSync(entry.path); ++ entry.dirent = utils$5.fs.createDirentFromStats(entry.name, stats); ++ } catch (error) { ++ if (settings.throwErrorOnBrokenSymbolicLink) { ++ throw error; ++ } ++ } ++ } ++ ++ return entry; ++ }); ++ } ++ ++ exports.readdirWithFileTypes = readdirWithFileTypes; ++ ++ function readdir(directory, settings) { ++ const names = settings.fs.readdirSync(directory); ++ return names.map(name => { ++ const entryPath = `${directory}${settings.pathSegmentSeparator}${name}`; ++ const stats = out.statSync(entryPath, settings.fsStatSettings); ++ const entry = { ++ name, ++ path: entryPath, ++ dirent: utils$5.fs.createDirentFromStats(name, stats) ++ }; ++ ++ if (settings.stats) { ++ entry.stats = stats; ++ } ++ ++ return entry; ++ }); ++ } ++ ++ exports.readdir = readdir; ++}); ++unwrapExports(sync$1); ++var sync_1$1 = sync$1.read; ++var sync_2 = sync$1.readdirWithFileTypes; ++var sync_3 = sync$1.readdir; ++ ++var fs_1$3 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ exports.FILE_SYSTEM_ADAPTER = { ++ lstat: fs$2.lstat, ++ stat: fs$2.stat, ++ lstatSync: fs$2.lstatSync, ++ statSync: fs$2.statSync, ++ readdir: fs$2.readdir, ++ readdirSync: fs$2.readdirSync ++ }; ++ ++ function createFileSystemAdapter(fsMethods) { ++ if (fsMethods === undefined) { ++ return exports.FILE_SYSTEM_ADAPTER; ++ } ++ ++ return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods); ++ } ++ ++ exports.createFileSystemAdapter = createFileSystemAdapter; ++}); ++unwrapExports(fs_1$3); ++var fs_2$1 = fs_1$3.FILE_SYSTEM_ADAPTER; ++var fs_3$1 = fs_1$3.createFileSystemAdapter; ++ ++var settings$1 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class Settings { ++ constructor(_options = {}) { ++ this._options = _options; ++ this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false); ++ this.fs = fs_1$3.createFileSystemAdapter(this._options.fs); ++ this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path$1.sep); ++ this.stats = this._getValue(this._options.stats, false); ++ this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true); ++ this.fsStatSettings = new out.Settings({ ++ followSymbolicLink: this.followSymbolicLinks, ++ fs: this.fs, ++ throwErrorOnBrokenSymbolicLink: this.throwErrorOnBrokenSymbolicLink ++ }); ++ } ++ ++ _getValue(option, value) { ++ return option === undefined ? value : option; ++ } ++ ++ } ++ ++ exports.default = Settings; ++}); ++unwrapExports(settings$1); ++ ++var out$1 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ exports.Settings = settings$1.default; ++ ++ function scandir(path, optionsOrSettingsOrCallback, callback) { ++ if (typeof optionsOrSettingsOrCallback === 'function') { ++ return async$1.read(path, getSettings(), optionsOrSettingsOrCallback); ++ } ++ ++ async$1.read(path, getSettings(optionsOrSettingsOrCallback), callback); ++ } ++ ++ exports.scandir = scandir; ++ ++ function scandirSync(path, optionsOrSettings) { ++ const settings = getSettings(optionsOrSettings); ++ return sync$1.read(path, settings); ++ } ++ ++ exports.scandirSync = scandirSync; ++ ++ function getSettings(settingsOrOptions = {}) { ++ if (settingsOrOptions instanceof settings$1.default) { ++ return settingsOrOptions; ++ } ++ ++ return new settings$1.default(settingsOrOptions); ++ } ++}); ++unwrapExports(out$1); ++var out_1$1 = out$1.Settings; ++var out_2$1 = out$1.scandir; ++var out_3$1 = out$1.scandirSync; ++ ++function reusify(Constructor) { ++ var head = new Constructor(); ++ var tail = head; ++ ++ function get() { ++ var current = head; ++ ++ if (current.next) { ++ head = current.next; ++ } else { ++ head = new Constructor(); ++ tail = head; ++ } ++ ++ current.next = null; ++ return current; ++ } ++ ++ function release(obj) { ++ tail.next = obj; ++ tail = obj; ++ } ++ ++ return { ++ get: get, ++ release: release ++ }; ++} ++ ++var reusify_1 = reusify; ++ ++function fastqueue(context, worker, concurrency) { ++ if (typeof context === 'function') { ++ concurrency = worker; ++ worker = context; ++ context = null; ++ } ++ ++ var cache = reusify_1(Task); ++ var queueHead = null; ++ var queueTail = null; ++ var _running = 0; ++ var self = { ++ push: push, ++ drain: noop$1, ++ saturated: noop$1, ++ pause: pause, ++ paused: false, ++ concurrency: concurrency, ++ running: running, ++ resume: resume, ++ idle: idle, ++ length: length, ++ unshift: unshift, ++ empty: noop$1, ++ kill: kill, ++ killAndDrain: killAndDrain ++ }; ++ return self; ++ ++ function running() { ++ return _running; ++ } ++ ++ function pause() { ++ self.paused = true; ++ } ++ ++ function length() { ++ var current = queueHead; ++ var counter = 0; ++ ++ while (current) { ++ current = current.next; ++ counter++; ++ } ++ ++ return counter; ++ } ++ ++ function resume() { ++ if (!self.paused) return; ++ self.paused = false; ++ ++ for (var i = 0; i < self.concurrency; i++) { ++ _running++; ++ release(); ++ } ++ } ++ ++ function idle() { ++ return _running === 0 && self.length() === 0; ++ } ++ ++ function push(value, done) { ++ var current = cache.get(); ++ current.context = context; ++ current.release = release; ++ current.value = value; ++ current.callback = done || noop$1; ++ ++ if (_running === self.concurrency || self.paused) { ++ if (queueTail) { ++ queueTail.next = current; ++ queueTail = current; ++ } else { ++ queueHead = current; ++ queueTail = current; ++ self.saturated(); ++ } ++ } else { ++ _running++; ++ worker.call(context, current.value, current.worked); ++ } ++ } ++ ++ function unshift(value, done) { ++ var current = cache.get(); ++ current.context = context; ++ current.release = release; ++ current.value = value; ++ current.callback = done || noop$1; ++ ++ if (_running === self.concurrency || self.paused) { ++ if (queueHead) { ++ current.next = queueHead; ++ queueHead = current; ++ } else { ++ queueHead = current; ++ queueTail = current; ++ self.saturated(); ++ } ++ } else { ++ _running++; ++ worker.call(context, current.value, current.worked); ++ } ++ } ++ ++ function release(holder) { ++ if (holder) { ++ cache.release(holder); ++ } ++ ++ var next = queueHead; ++ ++ if (next) { ++ if (!self.paused) { ++ if (queueTail === queueHead) { ++ queueTail = null; ++ } ++ ++ queueHead = next.next; ++ next.next = null; ++ worker.call(context, next.value, next.worked); ++ ++ if (queueTail === null) { ++ self.empty(); ++ } ++ } else { ++ _running--; ++ } ++ } else if (--_running === 0) { ++ self.drain(); ++ } ++ } ++ ++ function kill() { ++ queueHead = null; ++ queueTail = null; ++ self.drain = noop$1; ++ } ++ ++ function killAndDrain() { ++ queueHead = null; ++ queueTail = null; ++ self.drain(); ++ self.drain = noop$1; ++ } ++} ++ ++function noop$1() {} ++ ++function Task() { ++ this.value = null; ++ this.callback = noop$1; ++ this.next = null; ++ this.release = noop$1; ++ this.context = null; ++ var self = this; ++ ++ this.worked = function worked(err, result) { ++ var callback = self.callback; ++ self.value = null; ++ self.callback = noop$1; ++ callback.call(self.context, err, result); ++ self.release(self); ++ }; ++} ++ ++var queue = fastqueue; ++ ++var common$2 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ function isFatalError(settings, error) { ++ if (settings.errorFilter === null) { ++ return true; ++ } ++ ++ return !settings.errorFilter(error); ++ } ++ ++ exports.isFatalError = isFatalError; ++ ++ function isAppliedFilter(filter, value) { ++ return filter === null || filter(value); ++ } ++ ++ exports.isAppliedFilter = isAppliedFilter; ++ ++ function replacePathSegmentSeparator(filepath, separator) { ++ return filepath.split(/[\\/]/).join(separator); ++ } ++ ++ exports.replacePathSegmentSeparator = replacePathSegmentSeparator; ++ ++ function joinPathSegments(a, b, separator) { ++ if (a === '') { ++ return b; ++ } ++ ++ return a + separator + b; ++ } ++ ++ exports.joinPathSegments = joinPathSegments; ++}); ++unwrapExports(common$2); ++var common_1$2 = common$2.isFatalError; ++var common_2 = common$2.isAppliedFilter; ++var common_3 = common$2.replacePathSegmentSeparator; ++var common_4 = common$2.joinPathSegments; ++ ++var reader = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class Reader { ++ constructor(_root, _settings) { ++ this._root = _root; ++ this._settings = _settings; ++ this._root = common$2.replacePathSegmentSeparator(_root, _settings.pathSegmentSeparator); ++ } ++ ++ } ++ ++ exports.default = Reader; ++}); ++unwrapExports(reader); ++ ++var async$2 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class AsyncReader extends reader.default { ++ constructor(_root, _settings) { ++ super(_root, _settings); ++ this._settings = _settings; ++ this._scandir = out$1.scandir; ++ this._emitter = new events.EventEmitter(); ++ this._queue = queue(this._worker.bind(this), this._settings.concurrency); ++ this._isFatalError = false; ++ this._isDestroyed = false; ++ ++ this._queue.drain = () => { ++ if (!this._isFatalError) { ++ this._emitter.emit('end'); ++ } ++ }; ++ } ++ ++ read() { ++ this._isFatalError = false; ++ this._isDestroyed = false; ++ setImmediate(() => { ++ this._pushToQueue(this._root, this._settings.basePath); ++ }); ++ return this._emitter; ++ } ++ ++ destroy() { ++ if (this._isDestroyed) { ++ throw new Error('The reader is already destroyed'); ++ } ++ ++ this._isDestroyed = true; ++ ++ this._queue.killAndDrain(); ++ } ++ ++ onEntry(callback) { ++ this._emitter.on('entry', callback); ++ } ++ ++ onError(callback) { ++ this._emitter.once('error', callback); ++ } ++ ++ onEnd(callback) { ++ this._emitter.once('end', callback); ++ } ++ ++ _pushToQueue(directory, base) { ++ const queueItem = { ++ directory, ++ base ++ }; ++ ++ this._queue.push(queueItem, error => { ++ if (error !== null) { ++ this._handleError(error); ++ } ++ }); ++ } ++ ++ _worker(item, done) { ++ this._scandir(item.directory, this._settings.fsScandirSettings, (error, entries) => { ++ if (error !== null) { ++ return done(error, undefined); ++ } ++ ++ for (const entry of entries) { ++ this._handleEntry(entry, item.base); ++ } ++ ++ done(null, undefined); ++ }); ++ } ++ ++ _handleError(error) { ++ if (!common$2.isFatalError(this._settings, error)) { ++ return; ++ } ++ ++ this._isFatalError = true; ++ this._isDestroyed = true; ++ ++ this._emitter.emit('error', error); ++ } ++ ++ _handleEntry(entry, base) { ++ if (this._isDestroyed || this._isFatalError) { ++ return; ++ } ++ ++ const fullpath = entry.path; ++ ++ if (base !== undefined) { ++ entry.path = common$2.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator); ++ } ++ ++ if (common$2.isAppliedFilter(this._settings.entryFilter, entry)) { ++ this._emitEntry(entry); ++ } ++ ++ if (entry.dirent.isDirectory() && common$2.isAppliedFilter(this._settings.deepFilter, entry)) { ++ this._pushToQueue(fullpath, entry.path); ++ } ++ } ++ ++ _emitEntry(entry) { ++ this._emitter.emit('entry', entry); ++ } ++ ++ } ++ ++ exports.default = AsyncReader; ++}); ++unwrapExports(async$2); ++ ++var async$3 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class AsyncProvider { ++ constructor(_root, _settings) { ++ this._root = _root; ++ this._settings = _settings; ++ this._reader = new async$2.default(this._root, this._settings); ++ this._storage = new Set(); ++ } ++ ++ read(callback) { ++ this._reader.onError(error => { ++ callFailureCallback(callback, error); ++ }); ++ ++ this._reader.onEntry(entry => { ++ this._storage.add(entry); ++ }); ++ ++ this._reader.onEnd(() => { ++ callSuccessCallback(callback, [...this._storage]); ++ }); ++ ++ this._reader.read(); ++ } ++ ++ } ++ ++ exports.default = AsyncProvider; ++ ++ function callFailureCallback(callback, error) { ++ callback(error); ++ } ++ ++ function callSuccessCallback(callback, entries) { ++ callback(null, entries); ++ } ++}); ++unwrapExports(async$3); ++ ++var stream$1 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class StreamProvider { ++ constructor(_root, _settings) { ++ this._root = _root; ++ this._settings = _settings; ++ this._reader = new async$2.default(this._root, this._settings); ++ this._stream = new stream$5.Readable({ ++ objectMode: true, ++ read: () => {}, ++ destroy: this._reader.destroy.bind(this._reader) ++ }); ++ } ++ ++ read() { ++ this._reader.onError(error => { ++ this._stream.emit('error', error); ++ }); ++ ++ this._reader.onEntry(entry => { ++ this._stream.push(entry); ++ }); ++ ++ this._reader.onEnd(() => { ++ this._stream.push(null); ++ }); ++ ++ this._reader.read(); ++ ++ return this._stream; ++ } ++ ++ } ++ ++ exports.default = StreamProvider; ++}); ++unwrapExports(stream$1); ++ ++var sync$2 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class SyncReader extends reader.default { ++ constructor() { ++ super(...arguments); ++ this._scandir = out$1.scandirSync; ++ this._storage = new Set(); ++ this._queue = new Set(); ++ } ++ ++ read() { ++ this._pushToQueue(this._root, this._settings.basePath); ++ ++ this._handleQueue(); ++ ++ return [...this._storage]; ++ } ++ ++ _pushToQueue(directory, base) { ++ this._queue.add({ ++ directory, ++ base ++ }); ++ } ++ ++ _handleQueue() { ++ for (const item of this._queue.values()) { ++ this._handleDirectory(item.directory, item.base); ++ } ++ } ++ ++ _handleDirectory(directory, base) { ++ try { ++ const entries = this._scandir(directory, this._settings.fsScandirSettings); ++ ++ for (const entry of entries) { ++ this._handleEntry(entry, base); ++ } ++ } catch (error) { ++ this._handleError(error); ++ } ++ } ++ ++ _handleError(error) { ++ if (!common$2.isFatalError(this._settings, error)) { ++ return; ++ } ++ ++ throw error; ++ } ++ ++ _handleEntry(entry, base) { ++ const fullpath = entry.path; ++ ++ if (base !== undefined) { ++ entry.path = common$2.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator); ++ } ++ ++ if (common$2.isAppliedFilter(this._settings.entryFilter, entry)) { ++ this._pushToStorage(entry); ++ } ++ ++ if (entry.dirent.isDirectory() && common$2.isAppliedFilter(this._settings.deepFilter, entry)) { ++ this._pushToQueue(fullpath, entry.path); ++ } ++ } ++ ++ _pushToStorage(entry) { ++ this._storage.add(entry); ++ } ++ ++ } ++ ++ exports.default = SyncReader; ++}); ++unwrapExports(sync$2); ++ ++var sync$3 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class SyncProvider { ++ constructor(_root, _settings) { ++ this._root = _root; ++ this._settings = _settings; ++ this._reader = new sync$2.default(this._root, this._settings); ++ } ++ ++ read() { ++ return this._reader.read(); ++ } ++ ++ } ++ ++ exports.default = SyncProvider; ++}); ++unwrapExports(sync$3); ++ ++var settings$2 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class Settings { ++ constructor(_options = {}) { ++ this._options = _options; ++ this.basePath = this._getValue(this._options.basePath, undefined); ++ this.concurrency = this._getValue(this._options.concurrency, Infinity); ++ this.deepFilter = this._getValue(this._options.deepFilter, null); ++ this.entryFilter = this._getValue(this._options.entryFilter, null); ++ this.errorFilter = this._getValue(this._options.errorFilter, null); ++ this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path$1.sep); ++ this.fsScandirSettings = new out$1.Settings({ ++ followSymbolicLinks: this._options.followSymbolicLinks, ++ fs: this._options.fs, ++ pathSegmentSeparator: this._options.pathSegmentSeparator, ++ stats: this._options.stats, ++ throwErrorOnBrokenSymbolicLink: this._options.throwErrorOnBrokenSymbolicLink ++ }); ++ } ++ ++ _getValue(option, value) { ++ return option === undefined ? value : option; ++ } ++ ++ } ++ ++ exports.default = Settings; ++}); ++unwrapExports(settings$2); ++ ++var out$2 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ exports.Settings = settings$2.default; ++ ++ function walk(directory, optionsOrSettingsOrCallback, callback) { ++ if (typeof optionsOrSettingsOrCallback === 'function') { ++ return new async$3.default(directory, getSettings()).read(optionsOrSettingsOrCallback); ++ } ++ ++ new async$3.default(directory, getSettings(optionsOrSettingsOrCallback)).read(callback); ++ } ++ ++ exports.walk = walk; ++ ++ function walkSync(directory, optionsOrSettings) { ++ const settings = getSettings(optionsOrSettings); ++ const provider = new sync$3.default(directory, settings); ++ return provider.read(); ++ } ++ ++ exports.walkSync = walkSync; ++ ++ function walkStream(directory, optionsOrSettings) { ++ const settings = getSettings(optionsOrSettings); ++ const provider = new stream$1.default(directory, settings); ++ return provider.read(); ++ } ++ ++ exports.walkStream = walkStream; ++ ++ function getSettings(settingsOrOptions = {}) { ++ if (settingsOrOptions instanceof settings$2.default) { ++ return settingsOrOptions; ++ } ++ ++ return new settings$2.default(settingsOrOptions); ++ } ++}); ++unwrapExports(out$2); ++var out_1$2 = out$2.Settings; ++var out_2$2 = out$2.walk; ++var out_3$2 = out$2.walkSync; ++var out_4 = out$2.walkStream; ++ ++var reader$1 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class Reader { ++ constructor(_settings) { ++ this._settings = _settings; ++ this._fsStatSettings = new out.Settings({ ++ followSymbolicLink: this._settings.followSymbolicLinks, ++ fs: this._settings.fs, ++ throwErrorOnBrokenSymbolicLink: this._settings.followSymbolicLinks ++ }); ++ } ++ ++ _getFullEntryPath(filepath) { ++ return path$1.resolve(this._settings.cwd, filepath); ++ } ++ ++ _makeEntry(stats, pattern) { ++ const entry = { ++ name: pattern, ++ path: pattern, ++ dirent: utils$4.fs.createDirentFromStats(pattern, stats) ++ }; ++ ++ if (this._settings.stats) { ++ entry.stats = stats; ++ } ++ ++ return entry; ++ } ++ ++ _isFatalError(error) { ++ return !utils$4.errno.isEnoentCodeError(error) && !this._settings.suppressErrors; ++ } ++ ++ } ++ ++ exports.default = Reader; ++}); ++unwrapExports(reader$1); ++ ++var stream$2 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class ReaderStream extends reader$1.default { ++ constructor() { ++ super(...arguments); ++ this._walkStream = out$2.walkStream; ++ this._stat = out.stat; ++ } ++ ++ dynamic(root, options) { ++ return this._walkStream(root, options); ++ } ++ ++ static(patterns, options) { ++ const filepaths = patterns.map(this._getFullEntryPath, this); ++ const stream = new stream$5.PassThrough({ ++ objectMode: true ++ }); ++ ++ stream._write = (index, _enc, done) => { ++ return this._getEntry(filepaths[index], patterns[index], options).then(entry => { ++ if (entry !== null && options.entryFilter(entry)) { ++ stream.push(entry); ++ } ++ ++ if (index === filepaths.length - 1) { ++ stream.end(); ++ } ++ ++ done(); ++ }).catch(done); ++ }; ++ ++ for (let i = 0; i < filepaths.length; i++) { ++ stream.write(i); ++ } ++ ++ return stream; ++ } ++ ++ _getEntry(filepath, pattern, options) { ++ return this._getStat(filepath).then(stats => this._makeEntry(stats, pattern)).catch(error => { ++ if (options.errorFilter(error)) { ++ return null; ++ } ++ ++ throw error; ++ }); ++ } ++ ++ _getStat(filepath) { ++ return new Promise((resolve, reject) => { ++ this._stat(filepath, this._fsStatSettings, (error, stats) => { ++ return error === null ? resolve(stats) : reject(error); ++ }); ++ }); ++ } ++ ++ } ++ ++ exports.default = ReaderStream; ++}); ++unwrapExports(stream$2); ++ ++var matcher = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class Matcher { ++ constructor(_patterns, _settings, _micromatchOptions) { ++ this._patterns = _patterns; ++ this._settings = _settings; ++ this._micromatchOptions = _micromatchOptions; ++ this._storage = []; ++ ++ this._fillStorage(); ++ } ++ ++ _fillStorage() { ++ /** ++ * The original pattern may include `{,*,**,a/*}`, which will lead to problems with matching (unresolved level). ++ * So, before expand patterns with brace expansion into separated patterns. ++ */ ++ const patterns = utils$4.pattern.expandPatternsWithBraceExpansion(this._patterns); ++ ++ for (const pattern of patterns) { ++ const segments = this._getPatternSegments(pattern); ++ ++ const sections = this._splitSegmentsIntoSections(segments); ++ ++ this._storage.push({ ++ complete: sections.length <= 1, ++ pattern, ++ segments, ++ sections ++ }); ++ } ++ } ++ ++ _getPatternSegments(pattern) { ++ const parts = utils$4.pattern.getPatternParts(pattern, this._micromatchOptions); ++ return parts.map(part => { ++ const dynamic = utils$4.pattern.isDynamicPattern(part, this._settings); ++ ++ if (!dynamic) { ++ return { ++ dynamic: false, ++ pattern: part ++ }; ++ } ++ ++ return { ++ dynamic: true, ++ pattern: part, ++ patternRe: utils$4.pattern.makeRe(part, this._micromatchOptions) ++ }; ++ }); ++ } ++ ++ _splitSegmentsIntoSections(segments) { ++ return utils$4.array.splitWhen(segments, segment => segment.dynamic && utils$4.pattern.hasGlobStar(segment.pattern)); ++ } ++ ++ } ++ ++ exports.default = Matcher; ++}); ++unwrapExports(matcher); ++ ++var partial = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class PartialMatcher extends matcher.default { ++ match(filepath) { ++ const parts = filepath.split('/'); ++ const levels = parts.length; ++ ++ const patterns = this._storage.filter(info => !info.complete || info.segments.length > levels); ++ ++ for (const pattern of patterns) { ++ const section = pattern.sections[0]; ++ /** ++ * In this case, the pattern has a globstar and we must read all directories unconditionally, ++ * but only if the level has reached the end of the first group. ++ * ++ * fixtures/{a,b}/** ++ * ^ true/false ^ always true ++ */ ++ ++ if (!pattern.complete && levels > section.length) { ++ return true; ++ } ++ ++ const match = parts.every((part, index) => { ++ const segment = pattern.segments[index]; ++ ++ if (segment.dynamic && segment.patternRe.test(part)) { ++ return true; ++ } ++ ++ if (!segment.dynamic && segment.pattern === part) { ++ return true; ++ } ++ ++ return false; ++ }); ++ ++ if (match) { ++ return true; ++ } ++ } ++ ++ return false; ++ } ++ ++ } ++ ++ exports.default = PartialMatcher; ++}); ++unwrapExports(partial); ++ ++var deep = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class DeepFilter { ++ constructor(_settings, _micromatchOptions) { ++ this._settings = _settings; ++ this._micromatchOptions = _micromatchOptions; ++ } ++ ++ getFilter(basePath, positive, negative) { ++ const matcher = this._getMatcher(positive); ++ ++ const negativeRe = this._getNegativePatternsRe(negative); ++ ++ return entry => this._filter(basePath, entry, matcher, negativeRe); ++ } ++ ++ _getMatcher(patterns) { ++ return new partial.default(patterns, this._settings, this._micromatchOptions); ++ } ++ ++ _getNegativePatternsRe(patterns) { ++ const affectDepthOfReadingPatterns = patterns.filter(utils$4.pattern.isAffectDepthOfReadingPattern); ++ return utils$4.pattern.convertPatternsToRe(affectDepthOfReadingPatterns, this._micromatchOptions); ++ } ++ ++ _filter(basePath, entry, matcher, negativeRe) { ++ const depth = this._getEntryLevel(basePath, entry.path); ++ ++ if (this._isSkippedByDeep(depth)) { ++ return false; ++ } ++ ++ if (this._isSkippedSymbolicLink(entry)) { ++ return false; ++ } ++ ++ const filepath = utils$4.path.removeLeadingDotSegment(entry.path); ++ ++ if (this._isSkippedByPositivePatterns(filepath, matcher)) { ++ return false; ++ } ++ ++ return this._isSkippedByNegativePatterns(filepath, negativeRe); ++ } ++ ++ _isSkippedByDeep(entryDepth) { ++ return entryDepth >= this._settings.deep; ++ } ++ ++ _isSkippedSymbolicLink(entry) { ++ return !this._settings.followSymbolicLinks && entry.dirent.isSymbolicLink(); ++ } ++ ++ _getEntryLevel(basePath, entryPath) { ++ const basePathDepth = basePath.split('/').length; ++ const entryPathDepth = entryPath.split('/').length; ++ return entryPathDepth - (basePath === '' ? 0 : basePathDepth); ++ } ++ ++ _isSkippedByPositivePatterns(entryPath, matcher) { ++ return !this._settings.baseNameMatch && !matcher.match(entryPath); ++ } ++ ++ _isSkippedByNegativePatterns(entryPath, negativeRe) { ++ return !utils$4.pattern.matchAny(entryPath, negativeRe); ++ } ++ ++ } ++ ++ exports.default = DeepFilter; ++}); ++unwrapExports(deep); ++ ++var entry = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class EntryFilter { ++ constructor(_settings, _micromatchOptions) { ++ this._settings = _settings; ++ this._micromatchOptions = _micromatchOptions; ++ this.index = new Map(); ++ } ++ ++ getFilter(positive, negative) { ++ const positiveRe = utils$4.pattern.convertPatternsToRe(positive, this._micromatchOptions); ++ const negativeRe = utils$4.pattern.convertPatternsToRe(negative, this._micromatchOptions); ++ return entry => this._filter(entry, positiveRe, negativeRe); ++ } ++ ++ _filter(entry, positiveRe, negativeRe) { ++ if (this._settings.unique) { ++ if (this._isDuplicateEntry(entry)) { ++ return false; ++ } ++ ++ this._createIndexRecord(entry); ++ } ++ ++ if (this._onlyFileFilter(entry) || this._onlyDirectoryFilter(entry)) { ++ return false; ++ } ++ ++ if (this._isSkippedByAbsoluteNegativePatterns(entry, negativeRe)) { ++ return false; ++ } ++ ++ const filepath = this._settings.baseNameMatch ? entry.name : entry.path; ++ return this._isMatchToPatterns(filepath, positiveRe) && !this._isMatchToPatterns(entry.path, negativeRe); ++ } ++ ++ _isDuplicateEntry(entry) { ++ return this.index.has(entry.path); ++ } ++ ++ _createIndexRecord(entry) { ++ this.index.set(entry.path, undefined); ++ } ++ ++ _onlyFileFilter(entry) { ++ return this._settings.onlyFiles && !entry.dirent.isFile(); ++ } ++ ++ _onlyDirectoryFilter(entry) { ++ return this._settings.onlyDirectories && !entry.dirent.isDirectory(); ++ } ++ ++ _isSkippedByAbsoluteNegativePatterns(entry, negativeRe) { ++ if (!this._settings.absolute) { ++ return false; ++ } ++ ++ const fullpath = utils$4.path.makeAbsolute(this._settings.cwd, entry.path); ++ return this._isMatchToPatterns(fullpath, negativeRe); ++ } ++ ++ _isMatchToPatterns(entryPath, patternsRe) { ++ const filepath = utils$4.path.removeLeadingDotSegment(entryPath); ++ return utils$4.pattern.matchAny(filepath, patternsRe); ++ } ++ ++ } ++ ++ exports.default = EntryFilter; ++}); ++unwrapExports(entry); ++ ++var error = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class ErrorFilter { ++ constructor(_settings) { ++ this._settings = _settings; ++ } ++ ++ getFilter() { ++ return error => this._isNonFatalError(error); ++ } ++ ++ _isNonFatalError(error) { ++ return utils$4.errno.isEnoentCodeError(error) || this._settings.suppressErrors; ++ } ++ ++ } ++ ++ exports.default = ErrorFilter; ++}); ++unwrapExports(error); ++ ++var entry$1 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class EntryTransformer { ++ constructor(_settings) { ++ this._settings = _settings; ++ } ++ ++ getTransformer() { ++ return entry => this._transform(entry); ++ } ++ ++ _transform(entry) { ++ let filepath = entry.path; ++ ++ if (this._settings.absolute) { ++ filepath = utils$4.path.makeAbsolute(this._settings.cwd, filepath); ++ filepath = utils$4.path.unixify(filepath); ++ } ++ ++ if (this._settings.markDirectories && entry.dirent.isDirectory()) { ++ filepath += '/'; ++ } ++ ++ if (!this._settings.objectMode) { ++ return filepath; ++ } ++ ++ return Object.assign(Object.assign({}, entry), { ++ path: filepath ++ }); ++ } ++ ++ } ++ ++ exports.default = EntryTransformer; ++}); ++unwrapExports(entry$1); ++ ++var provider = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class Provider { ++ constructor(_settings) { ++ this._settings = _settings; ++ this.errorFilter = new error.default(this._settings); ++ this.entryFilter = new entry.default(this._settings, this._getMicromatchOptions()); ++ this.deepFilter = new deep.default(this._settings, this._getMicromatchOptions()); ++ this.entryTransformer = new entry$1.default(this._settings); ++ } ++ ++ _getRootDirectory(task) { ++ return path$1.resolve(this._settings.cwd, task.base); ++ } ++ ++ _getReaderOptions(task) { ++ const basePath = task.base === '.' ? '' : task.base; ++ return { ++ basePath, ++ pathSegmentSeparator: '/', ++ concurrency: this._settings.concurrency, ++ deepFilter: this.deepFilter.getFilter(basePath, task.positive, task.negative), ++ entryFilter: this.entryFilter.getFilter(task.positive, task.negative), ++ errorFilter: this.errorFilter.getFilter(), ++ followSymbolicLinks: this._settings.followSymbolicLinks, ++ fs: this._settings.fs, ++ stats: this._settings.stats, ++ throwErrorOnBrokenSymbolicLink: this._settings.throwErrorOnBrokenSymbolicLink, ++ transform: this.entryTransformer.getTransformer() ++ }; ++ } ++ ++ _getMicromatchOptions() { ++ return { ++ dot: this._settings.dot, ++ matchBase: this._settings.baseNameMatch, ++ nobrace: !this._settings.braceExpansion, ++ nocase: !this._settings.caseSensitiveMatch, ++ noext: !this._settings.extglob, ++ noglobstar: !this._settings.globstar, ++ posix: true, ++ strictSlashes: false ++ }; ++ } ++ ++ } ++ ++ exports.default = Provider; ++}); ++unwrapExports(provider); ++ ++var async$4 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class ProviderAsync extends provider.default { ++ constructor() { ++ super(...arguments); ++ this._reader = new stream$2.default(this._settings); ++ } ++ ++ read(task) { ++ const root = this._getRootDirectory(task); ++ ++ const options = this._getReaderOptions(task); ++ ++ const entries = []; ++ return new Promise((resolve, reject) => { ++ const stream = this.api(root, task, options); ++ stream.once('error', reject); ++ stream.on('data', entry => entries.push(options.transform(entry))); ++ stream.once('end', () => resolve(entries)); ++ }); ++ } ++ ++ api(root, task, options) { ++ if (task.dynamic) { ++ return this._reader.dynamic(root, options); ++ } ++ ++ return this._reader.static(task.patterns, options); ++ } ++ ++ } ++ ++ exports.default = ProviderAsync; ++}); ++unwrapExports(async$4); ++ ++var stream$3 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class ProviderStream extends provider.default { ++ constructor() { ++ super(...arguments); ++ this._reader = new stream$2.default(this._settings); ++ } ++ ++ read(task) { ++ const root = this._getRootDirectory(task); ++ ++ const options = this._getReaderOptions(task); ++ ++ const source = this.api(root, task, options); ++ const destination = new stream$5.Readable({ ++ objectMode: true, ++ read: () => {} ++ }); ++ source.once('error', error => destination.emit('error', error)).on('data', entry => destination.emit('data', options.transform(entry))).once('end', () => destination.emit('end')); ++ destination.once('close', () => source.destroy()); ++ return destination; ++ } ++ ++ api(root, task, options) { ++ if (task.dynamic) { ++ return this._reader.dynamic(root, options); ++ } ++ ++ return this._reader.static(task.patterns, options); ++ } ++ ++ } ++ ++ exports.default = ProviderStream; ++}); ++unwrapExports(stream$3); ++ ++var sync$4 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class ReaderSync extends reader$1.default { ++ constructor() { ++ super(...arguments); ++ this._walkSync = out$2.walkSync; ++ this._statSync = out.statSync; ++ } ++ ++ dynamic(root, options) { ++ return this._walkSync(root, options); ++ } ++ ++ static(patterns, options) { ++ const entries = []; ++ ++ for (const pattern of patterns) { ++ const filepath = this._getFullEntryPath(pattern); ++ ++ const entry = this._getEntry(filepath, pattern, options); ++ ++ if (entry === null || !options.entryFilter(entry)) { ++ continue; ++ } ++ ++ entries.push(entry); ++ } ++ ++ return entries; ++ } ++ ++ _getEntry(filepath, pattern, options) { ++ try { ++ const stats = this._getStat(filepath); ++ ++ return this._makeEntry(stats, pattern); ++ } catch (error) { ++ if (options.errorFilter(error)) { ++ return null; ++ } ++ ++ throw error; ++ } ++ } ++ ++ _getStat(filepath) { ++ return this._statSync(filepath, this._fsStatSettings); ++ } ++ ++ } ++ ++ exports.default = ReaderSync; ++}); ++unwrapExports(sync$4); ++ ++var sync$5 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ ++ class ProviderSync extends provider.default { ++ constructor() { ++ super(...arguments); ++ this._reader = new sync$4.default(this._settings); ++ } ++ ++ read(task) { ++ const root = this._getRootDirectory(task); ++ ++ const options = this._getReaderOptions(task); ++ ++ const entries = this.api(root, task, options); ++ return entries.map(options.transform); ++ } ++ ++ api(root, task, options) { ++ if (task.dynamic) { ++ return this._reader.dynamic(root, options); ++ } ++ ++ return this._reader.static(task.patterns, options); ++ } ++ ++ } ++ ++ exports.default = ProviderSync; ++}); ++unwrapExports(sync$5); ++ ++var settings$3 = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, "__esModule", { ++ value: true ++ }); ++ const CPU_COUNT = os.cpus().length; ++ exports.DEFAULT_FILE_SYSTEM_ADAPTER = { ++ lstat: fs$2.lstat, ++ lstatSync: fs$2.lstatSync, ++ stat: fs$2.stat, ++ statSync: fs$2.statSync, ++ readdir: fs$2.readdir, ++ readdirSync: fs$2.readdirSync ++ }; ++ ++ class Settings { ++ constructor(_options = {}) { ++ this._options = _options; ++ this.absolute = this._getValue(this._options.absolute, false); ++ this.baseNameMatch = this._getValue(this._options.baseNameMatch, false); ++ this.braceExpansion = this._getValue(this._options.braceExpansion, true); ++ this.caseSensitiveMatch = this._getValue(this._options.caseSensitiveMatch, true); ++ this.concurrency = this._getValue(this._options.concurrency, CPU_COUNT); ++ this.cwd = this._getValue(this._options.cwd, process.cwd()); ++ this.deep = this._getValue(this._options.deep, Infinity); ++ this.dot = this._getValue(this._options.dot, false); ++ this.extglob = this._getValue(this._options.extglob, true); ++ this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, true); ++ this.fs = this._getFileSystemMethods(this._options.fs); ++ this.globstar = this._getValue(this._options.globstar, true); ++ this.ignore = this._getValue(this._options.ignore, []); ++ this.markDirectories = this._getValue(this._options.markDirectories, false); ++ this.objectMode = this._getValue(this._options.objectMode, false); ++ this.onlyDirectories = this._getValue(this._options.onlyDirectories, false); ++ this.onlyFiles = this._getValue(this._options.onlyFiles, true); ++ this.stats = this._getValue(this._options.stats, false); ++ this.suppressErrors = this._getValue(this._options.suppressErrors, false); ++ this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, false); ++ this.unique = this._getValue(this._options.unique, true); ++ ++ if (this.onlyDirectories) { ++ this.onlyFiles = false; ++ } ++ ++ if (this.stats) { ++ this.objectMode = true; ++ } ++ } ++ ++ _getValue(option, value) { ++ return option === undefined ? value : option; ++ } ++ ++ _getFileSystemMethods(methods = {}) { ++ return Object.assign(Object.assign({}, exports.DEFAULT_FILE_SYSTEM_ADAPTER), methods); ++ } ++ ++ } ++ ++ exports.default = Settings; ++}); ++unwrapExports(settings$3); ++var settings_1 = settings$3.DEFAULT_FILE_SYSTEM_ADAPTER; ++ ++async function FastGlob(source, options) { ++ assertPatternsInput(source); ++ const works = getWorks(source, async$4.default, options); ++ const result = await Promise.all(works); ++ return utils$4.array.flatten(result); ++} // https://github.com/typescript-eslint/typescript-eslint/issues/60 ++// eslint-disable-next-line no-redeclare ++ ++ ++(function (FastGlob) { ++ function sync(source, options) { ++ assertPatternsInput(source); ++ const works = getWorks(source, sync$5.default, options); ++ return utils$4.array.flatten(works); ++ } ++ ++ FastGlob.sync = sync; ++ ++ function stream(source, options) { ++ assertPatternsInput(source); ++ const works = getWorks(source, stream$3.default, options); ++ /** ++ * The stream returned by the provider cannot work with an asynchronous iterator. ++ * To support asynchronous iterators, regardless of the number of tasks, we always multiplex streams. ++ * This affects performance (+25%). I don't see best solution right now. ++ */ ++ ++ return utils$4.stream.merge(works); ++ } ++ ++ FastGlob.stream = stream; ++ ++ function generateTasks(source, options) { ++ assertPatternsInput(source); ++ const patterns = [].concat(source); ++ const settings = new settings$3.default(options); ++ return tasks.generate(patterns, settings); ++ } ++ ++ FastGlob.generateTasks = generateTasks; ++ ++ function isDynamicPattern(source, options) { ++ assertPatternsInput(source); ++ const settings = new settings$3.default(options); ++ return utils$4.pattern.isDynamicPattern(source, settings); ++ } ++ ++ FastGlob.isDynamicPattern = isDynamicPattern; ++ ++ function escapePath(source) { ++ assertPatternsInput(source); ++ return utils$4.path.escape(source); ++ } ++ ++ FastGlob.escapePath = escapePath; ++})(FastGlob || (FastGlob = {})); ++ ++function getWorks(source, _Provider, options) { ++ const patterns = [].concat(source); ++ const settings = new settings$3.default(options); ++ const tasks$1 = tasks.generate(patterns, settings); ++ const provider = new _Provider(settings); ++ return tasks$1.map(provider.read, provider); ++} ++ ++function assertPatternsInput(input) { ++ const source = [].concat(input); ++ const isValidSource = source.every(item => utils$4.string.isString(item) && !utils$4.string.isEmpty(item)); ++ ++ if (!isValidSource) { ++ throw new TypeError('Patterns must be a string (non empty) or an array of strings'); ++ } ++} ++ ++var out$3 = FastGlob; ++ ++const { ++ promisify ++} = util$3; ++ ++async function isType(fsStatType, statsMethodName, filePath) { ++ if (typeof filePath !== 'string') { ++ throw new TypeError(`Expected a string, got ${typeof filePath}`); ++ } ++ ++ try { ++ const stats = await promisify(fs$2[fsStatType])(filePath); ++ return stats[statsMethodName](); ++ } catch (error) { ++ if (error.code === 'ENOENT') { ++ return false; ++ } ++ ++ throw error; ++ } ++} ++ ++function isTypeSync(fsStatType, statsMethodName, filePath) { ++ if (typeof filePath !== 'string') { ++ throw new TypeError(`Expected a string, got ${typeof filePath}`); ++ } ++ ++ try { ++ return fs$2[fsStatType](filePath)[statsMethodName](); ++ } catch (error) { ++ if (error.code === 'ENOENT') { ++ return false; ++ } ++ ++ throw error; ++ } ++} ++ ++var isFile = isType.bind(null, 'stat', 'isFile'); ++var isDirectory = isType.bind(null, 'stat', 'isDirectory'); ++var isSymlink = isType.bind(null, 'lstat', 'isSymbolicLink'); ++var isFileSync = isTypeSync.bind(null, 'statSync', 'isFile'); ++var isDirectorySync = isTypeSync.bind(null, 'statSync', 'isDirectory'); ++var isSymlinkSync = isTypeSync.bind(null, 'lstatSync', 'isSymbolicLink'); ++var pathType = { ++ isFile: isFile, ++ isDirectory: isDirectory, ++ isSymlink: isSymlink, ++ isFileSync: isFileSync, ++ isDirectorySync: isDirectorySync, ++ isSymlinkSync: isSymlinkSync ++}; ++ ++const getExtensions = extensions => extensions.length > 1 ? `{${extensions.join(',')}}` : extensions[0]; ++ ++const getPath = (filepath, cwd) => { ++ const pth = filepath[0] === '!' ? filepath.slice(1) : filepath; ++ return path$1.isAbsolute(pth) ? pth : path$1.join(cwd, pth); ++}; ++ ++const addExtensions = (file, extensions) => { ++ if (path$1.extname(file)) { ++ return `**/${file}`; ++ } ++ ++ return `**/${file}.${getExtensions(extensions)}`; ++}; ++ ++const getGlob = (directory, options) => { ++ if (options.files && !Array.isArray(options.files)) { ++ throw new TypeError(`Expected \`files\` to be of type \`Array\` but received type \`${typeof options.files}\``); ++ } ++ ++ if (options.extensions && !Array.isArray(options.extensions)) { ++ throw new TypeError(`Expected \`extensions\` to be of type \`Array\` but received type \`${typeof options.extensions}\``); ++ } ++ ++ if (options.files && options.extensions) { ++ return options.files.map(x => path$1.posix.join(directory, addExtensions(x, options.extensions))); ++ } ++ ++ if (options.files) { ++ return options.files.map(x => path$1.posix.join(directory, `**/${x}`)); ++ } ++ ++ if (options.extensions) { ++ return [path$1.posix.join(directory, `**/*.${getExtensions(options.extensions)}`)]; ++ } ++ ++ return [path$1.posix.join(directory, '**')]; ++}; ++ ++var dirGlob = async (input, options) => { ++ options = Object.assign({ ++ cwd: process.cwd() ++ }, options); ++ ++ if (typeof options.cwd !== 'string') { ++ throw new TypeError(`Expected \`cwd\` to be of type \`string\` but received type \`${typeof options.cwd}\``); ++ } ++ ++ const globs = await Promise.all([].concat(input).map(async x => { ++ const isDirectory = await pathType.isDirectory(getPath(x, options.cwd)); ++ return isDirectory ? getGlob(x, options) : x; ++ })); ++ return [].concat.apply([], globs); // eslint-disable-line prefer-spread ++}; ++ ++var sync$6 = (input, options) => { ++ options = Object.assign({ ++ cwd: process.cwd() ++ }, options); ++ ++ if (typeof options.cwd !== 'string') { ++ throw new TypeError(`Expected \`cwd\` to be of type \`string\` but received type \`${typeof options.cwd}\``); ++ } ++ ++ const globs = [].concat(input).map(x => pathType.isDirectorySync(getPath(x, options.cwd)) ? getGlob(x, options) : x); ++ return [].concat.apply([], globs); // eslint-disable-line prefer-spread ++}; ++dirGlob.sync = sync$6; ++ ++// A simple implementation of make-array ++function makeArray(subject) { ++ return Array.isArray(subject) ? subject : [subject]; ++} ++ ++const REGEX_TEST_BLANK_LINE = /^\s+$/; ++const REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/; ++const REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/; ++const REGEX_SPLITALL_CRLF = /\r?\n/g; // /foo, ++// ./foo, ++// ../foo, ++// . ++// .. ++ ++const REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/; ++const SLASH$1 = '/'; ++const KEY_IGNORE$1 = typeof Symbol !== 'undefined' ? Symbol.for('node-ignore') ++/* istanbul ignore next */ ++: 'node-ignore'; ++ ++const define$1 = (object, key, value) => Object.defineProperty(object, key, { ++ value ++}); ++ ++const REGEX_REGEXP_RANGE$1 = /([0-z])-([0-z])/g; // Sanitize the range of a regular expression ++// The cases are complicated, see test cases for details ++ ++const sanitizeRange$1 = range => range.replace(REGEX_REGEXP_RANGE$1, (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match // Invalid range (out of order) which is ok for gitignore rules but ++// fatal for JavaScript regular expression, so eliminate it. ++: ''); // > If the pattern ends with a slash, ++// > it is removed for the purpose of the following description, ++// > but it would only find a match with a directory. ++// > In other words, foo/ will match a directory foo and paths underneath it, ++// > but will not match a regular file or a symbolic link foo ++// > (this is consistent with the way how pathspec works in general in Git). ++// '`foo/`' will not match regular file '`foo`' or symbolic link '`foo`' ++// -> ignore-rules will not deal with it, because it costs extra `fs.stat` call ++// you could use option `mark: true` with `glob` ++// '`foo/`' should not continue with the '`..`' ++ ++ ++const REPLACERS = [// > Trailing spaces are ignored unless they are quoted with backslash ("\") ++[// (a\ ) -> (a ) ++// (a ) -> (a) ++// (a \ ) -> (a ) ++/\\?\s+$/, match => match.indexOf('\\') === 0 ? ' ' : ''], // replace (\ ) with ' ' ++[/\\\s/g, () => ' '], // Escape metacharacters ++// which is written down by users but means special for regular expressions. ++// > There are 12 characters with special meanings: ++// > - the backslash \, ++// > - the caret ^, ++// > - the dollar sign $, ++// > - the period or dot ., ++// > - the vertical bar or pipe symbol |, ++// > - the question mark ?, ++// > - the asterisk or star *, ++// > - the plus sign +, ++// > - the opening parenthesis (, ++// > - the closing parenthesis ), ++// > - and the opening square bracket [, ++// > - the opening curly brace {, ++// > These special characters are often called "metacharacters". ++[/[\\^$.|*+(){]/g, match => `\\${match}`], [// > [abc] matches any character inside the brackets ++// > (in this case a, b, or c); ++/\[([^\]/]*)($|\])/g, (match, p1, p2) => p2 === ']' ? `[${sanitizeRange$1(p1)}]` : `\\${match}`], [// > a question mark (?) matches a single character ++/(?!\\)\?/g, () => '[^/]'], // leading slash ++[// > A leading slash matches the beginning of the pathname. ++// > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c". ++// A leading slash matches the beginning of the pathname ++/^\//, () => '^'], // replace special metacharacter slash after the leading slash ++[/\//g, () => '\\/'], [// > A leading "**" followed by a slash means match in all directories. ++// > For example, "**/foo" matches file or directory "foo" anywhere, ++// > the same as pattern "foo". ++// > "**/foo/bar" matches file or directory "bar" anywhere that is directly ++// > under directory "foo". ++// Notice that the '*'s have been replaced as '\\*' ++/^\^*\\\*\\\*\\\//, // '**/foo' <-> 'foo' ++() => '^(?:.*\\/)?'], // ending ++[// 'js' will not match 'js.' ++// 'ab' will not match 'abc' ++/(?:[^*])$/, // WTF! ++// https://git-scm.com/docs/gitignore ++// changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1) ++// which re-fixes #24, #38 ++// > If there is a separator at the end of the pattern then the pattern ++// > will only match directories, otherwise the pattern can match both ++// > files and directories. ++// 'js*' will not match 'a.js' ++// 'js/' will not match 'a.js' ++// 'js' will match 'a.js' and 'a.js/' ++match => /\/$/.test(match) // foo/ will not match 'foo' ++? `${match}$` // foo matches 'foo' and 'foo/' ++: `${match}(?=$|\\/$)`], // starting ++[// there will be no leading '/' ++// (which has been replaced by section "leading slash") ++// If starts with '**', adding a '^' to the regular expression also works ++/^(?=[^^])/, function startingReplacer() { ++ // If has a slash `/` at the beginning or middle ++ return !/\/(?!$)/.test(this) // > Prior to 2.22.1 ++ // > If the pattern does not contain a slash /, ++ // > Git treats it as a shell glob pattern ++ // Actually, if there is only a trailing slash, ++ // git also treats it as a shell glob pattern ++ // After 2.22.1 (compatible but clearer) ++ // > If there is a separator at the beginning or middle (or both) ++ // > of the pattern, then the pattern is relative to the directory ++ // > level of the particular .gitignore file itself. ++ // > Otherwise the pattern may also match at any level below ++ // > the .gitignore level. ++ ? '(?:^|\\/)' // > Otherwise, Git treats the pattern as a shell glob suitable for ++ // > consumption by fnmatch(3) ++ : '^'; ++}], // two globstars ++[// Use lookahead assertions so that we could match more than one `'/**'` ++/\\\/\\\*\\\*(?=\\\/|$)/g, // Zero, one or several directories ++// should not use '*', or it will be replaced by the next replacer ++// Check if it is not the last `'/**'` ++(_, index, str) => index + 6 < str.length // case: /**/ ++// > A slash followed by two consecutive asterisks then a slash matches ++// > zero or more directories. ++// > For example, "a/**/b" matches "a/b", "a/x/b", "a/x/y/b" and so on. ++// '/**/' ++? '(?:\\/[^\\/]+)*' // case: /** ++// > A trailing `"/**"` matches everything inside. ++// #21: everything inside but it should not include the current folder ++: '\\/.+'], // intermediate wildcards ++[// Never replace escaped '*' ++// ignore rule '\*' will match the path '*' ++// 'abc.*/' -> go ++// 'abc.*' -> skip this rule ++/(^|[^\\]+)\\\*(?=.+)/g, // '*.js' matches '.js' ++// '*.js' doesn't match 'abc' ++(_, p1) => `${p1}[^\\/]*`], // trailing wildcard ++[/(\^|\\\/)?\\\*$/, (_, p1) => { ++ const prefix = p1 // '\^': ++ // '/*' does not match '' ++ // '/*' does not match everything ++ // '\\\/': ++ // 'abc/*' does not match 'abc/' ++ ? `${p1}[^/]+` // 'a*' matches 'a' ++ // 'a*' matches 'aa' ++ : '[^/]*'; ++ return `${prefix}(?=$|\\/$)`; ++}], [// unescape ++/\\\\\\/g, () => '\\']]; // A simple cache, because an ignore rule only has only one certain meaning ++ ++const regexCache = Object.create(null); // @param {pattern} ++ ++const makeRegex = (pattern, negative, ignorecase) => { ++ const r = regexCache[pattern]; ++ ++ if (r) { ++ return r; ++ } // const replacers = negative ++ // ? NEGATIVE_REPLACERS ++ // : POSITIVE_REPLACERS ++ ++ ++ const source = REPLACERS.reduce((prev, current) => prev.replace(current[0], current[1].bind(pattern)), pattern); ++ return regexCache[pattern] = ignorecase ? new RegExp(source, 'i') : new RegExp(source); ++}; ++ ++const isString = subject => typeof subject === 'string'; // > A blank line matches no files, so it can serve as a separator for readability. ++ ++ ++const checkPattern$1 = pattern => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) // > A line starting with # serves as a comment. ++&& pattern.indexOf('#') !== 0; ++ ++const splitPattern = pattern => pattern.split(REGEX_SPLITALL_CRLF); ++ ++class IgnoreRule { ++ constructor(origin, pattern, negative, regex) { ++ this.origin = origin; ++ this.pattern = pattern; ++ this.negative = negative; ++ this.regex = regex; ++ } ++ ++} ++ ++const createRule$1 = (pattern, ignorecase) => { ++ const origin = pattern; ++ let negative = false; // > An optional prefix "!" which negates the pattern; ++ ++ if (pattern.indexOf('!') === 0) { ++ negative = true; ++ pattern = pattern.substr(1); ++ } ++ ++ pattern = pattern // > Put a backslash ("\") in front of the first "!" for patterns that ++ // > begin with a literal "!", for example, `"\!important!.txt"`. ++ .replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, '!') // > Put a backslash ("\") in front of the first hash for patterns that ++ // > begin with a hash. ++ .replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, '#'); ++ const regex = makeRegex(pattern, negative, ignorecase); ++ return new IgnoreRule(origin, pattern, negative, regex); ++}; ++ ++const throwError = (message, Ctor) => { ++ throw new Ctor(message); ++}; ++ ++const checkPath = (path, originalPath, doThrow) => { ++ if (!isString(path)) { ++ return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError); ++ } // We don't know if we should ignore '', so throw ++ ++ ++ if (!path) { ++ return doThrow(`path must not be empty`, TypeError); ++ } // Check if it is a relative path ++ ++ ++ if (checkPath.isNotRelative(path)) { ++ const r = '`path.relative()`d'; ++ return doThrow(`path should be a ${r} string, but got "${originalPath}"`, RangeError); ++ } ++ ++ return true; ++}; ++ ++const isNotRelative = path => REGEX_TEST_INVALID_PATH.test(path); ++ ++checkPath.isNotRelative = isNotRelative; ++ ++checkPath.convert = p => p; ++ ++class Ignore { ++ constructor({ ++ ignorecase = true ++ } = {}) { ++ this._rules = []; ++ this._ignorecase = ignorecase; ++ define$1(this, KEY_IGNORE$1, true); ++ ++ this._initCache(); ++ } ++ ++ _initCache() { ++ this._ignoreCache = Object.create(null); ++ this._testCache = Object.create(null); ++ } ++ ++ _addPattern(pattern) { ++ // #32 ++ if (pattern && pattern[KEY_IGNORE$1]) { ++ this._rules = this._rules.concat(pattern._rules); ++ this._added = true; ++ return; ++ } ++ ++ if (checkPattern$1(pattern)) { ++ const rule = createRule$1(pattern, this._ignorecase); ++ this._added = true; ++ ++ this._rules.push(rule); ++ } ++ } // @param {Array | string | Ignore} pattern ++ ++ ++ add(pattern) { ++ this._added = false; ++ makeArray(isString(pattern) ? splitPattern(pattern) : pattern).forEach(this._addPattern, this); // Some rules have just added to the ignore, ++ // making the behavior changed. ++ ++ if (this._added) { ++ this._initCache(); ++ } ++ ++ return this; ++ } // legacy ++ ++ ++ addPattern(pattern) { ++ return this.add(pattern); ++ } // | ignored : unignored ++ // negative | 0:0 | 0:1 | 1:0 | 1:1 ++ // -------- | ------- | ------- | ------- | -------- ++ // 0 | TEST | TEST | SKIP | X ++ // 1 | TESTIF | SKIP | TEST | X ++ // - SKIP: always skip ++ // - TEST: always test ++ // - TESTIF: only test if checkUnignored ++ // - X: that never happen ++ // @param {boolean} whether should check if the path is unignored, ++ // setting `checkUnignored` to `false` could reduce additional ++ // path matching. ++ // @returns {TestResult} true if a file is ignored ++ ++ ++ _testOne(path, checkUnignored) { ++ let ignored = false; ++ let unignored = false; ++ ++ this._rules.forEach(rule => { ++ const { ++ negative ++ } = rule; ++ ++ if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) { ++ return; ++ } ++ ++ const matched = rule.regex.test(path); ++ ++ if (matched) { ++ ignored = !negative; ++ unignored = negative; ++ } ++ }); ++ ++ return { ++ ignored, ++ unignored ++ }; ++ } // @returns {TestResult} ++ ++ ++ _test(originalPath, cache, checkUnignored, slices) { ++ const path = originalPath // Supports nullable path ++ && checkPath.convert(originalPath); ++ checkPath(path, originalPath, throwError); ++ return this._t(path, cache, checkUnignored, slices); ++ } ++ ++ _t(path, cache, checkUnignored, slices) { ++ if (path in cache) { ++ return cache[path]; ++ } ++ ++ if (!slices) { ++ // path/to/a.js ++ // ['path', 'to', 'a.js'] ++ slices = path.split(SLASH$1); ++ } ++ ++ slices.pop(); // If the path has no parent directory, just test it ++ ++ if (!slices.length) { ++ return cache[path] = this._testOne(path, checkUnignored); ++ } ++ ++ const parent = this._t(slices.join(SLASH$1) + SLASH$1, cache, checkUnignored, slices); // If the path contains a parent directory, check the parent first ++ ++ ++ return cache[path] = parent.ignored // > It is not possible to re-include a file if a parent directory of ++ // > that file is excluded. ++ ? parent : this._testOne(path, checkUnignored); ++ } ++ ++ ignores(path) { ++ return this._test(path, this._ignoreCache, false).ignored; ++ } ++ ++ createFilter() { ++ return path => !this.ignores(path); ++ } ++ ++ filter(paths) { ++ return makeArray(paths).filter(this.createFilter()); ++ } // @returns {TestResult} ++ ++ ++ test(path) { ++ return this._test(path, this._testCache, true); ++ } ++ ++} ++ ++const factory = options => new Ignore(options); ++ ++const returnFalse = () => false; ++ ++const isPathValid = path => checkPath(path && checkPath.convert(path), path, returnFalse); ++ ++factory.isPathValid = isPathValid; // Fixes typescript ++ ++factory.default = factory; ++var ignore$1 = factory; // Windows ++// -------------------------------------------------------------- ++ ++/* istanbul ignore if */ ++ ++if ( // Detect `process` so that it can run in browsers. ++typeof process !== 'undefined' && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === 'win32')) { ++ /* eslint no-control-regex: "off" */ ++ const makePosix = str => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, '/'); ++ ++ checkPath.convert = makePosix; // 'C:\\foo' <- 'C:\\foo' has been converted to 'C:/' ++ // 'd:\\foo' ++ ++ const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i; ++ ++ checkPath.isNotRelative = path => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path) || isNotRelative(path); ++} ++ ++var slash$1 = path => { ++ const isExtendedLengthPath = /^\\\\\?\\/.test(path); ++ const hasNonAscii = /[^\u0000-\u0080]+/.test(path); // eslint-disable-line no-control-regex ++ ++ if (isExtendedLengthPath || hasNonAscii) { ++ return path; ++ } ++ ++ return path.replace(/\\/g, '/'); ++}; ++ ++const { ++ promisify: promisify$1 ++} = util$3; ++const DEFAULT_IGNORE = ['**/node_modules/**', '**/flow-typed/**', '**/coverage/**', '**/.git']; ++const readFileP = promisify$1(fs$2.readFile); ++ ++const mapGitIgnorePatternTo = base => ignore => { ++ if (ignore.startsWith('!')) { ++ return '!' + path$1.posix.join(base, ignore.slice(1)); ++ } ++ ++ return path$1.posix.join(base, ignore); ++}; ++ ++const parseGitIgnore = (content, options) => { ++ const base = slash$1(path$1.relative(options.cwd, path$1.dirname(options.fileName))); ++ return content.split(/\r?\n/).filter(Boolean).filter(line => !line.startsWith('#')).map(mapGitIgnorePatternTo(base)); ++}; ++ ++const reduceIgnore = files => { ++ return files.reduce((ignores, file) => { ++ ignores.add(parseGitIgnore(file.content, { ++ cwd: file.cwd, ++ fileName: file.filePath ++ })); ++ return ignores; ++ }, ignore$1()); ++}; ++ ++const ensureAbsolutePathForCwd = (cwd, p) => { ++ if (path$1.isAbsolute(p)) { ++ if (p.startsWith(cwd)) { ++ return p; ++ } ++ ++ throw new Error(`Path ${p} is not in cwd ${cwd}`); ++ } ++ ++ return path$1.join(cwd, p); ++}; ++ ++const getIsIgnoredPredecate = (ignores, cwd) => { ++ return p => ignores.ignores(slash$1(path$1.relative(cwd, ensureAbsolutePathForCwd(cwd, p)))); ++}; ++ ++const getFile = async (file, cwd) => { ++ const filePath = path$1.join(cwd, file); ++ const content = await readFileP(filePath, 'utf8'); ++ return { ++ cwd, ++ filePath, ++ content ++ }; ++}; ++ ++const getFileSync = (file, cwd) => { ++ const filePath = path$1.join(cwd, file); ++ const content = fs$2.readFileSync(filePath, 'utf8'); ++ return { ++ cwd, ++ filePath, ++ content ++ }; ++}; ++ ++const normalizeOptions$2 = ({ ++ ignore = [], ++ cwd = slash$1(process.cwd()) ++} = {}) => { ++ return { ++ ignore, ++ cwd ++ }; ++}; ++ ++var gitignore = async options => { ++ options = normalizeOptions$2(options); ++ const paths = await out$3('**/.gitignore', { ++ ignore: DEFAULT_IGNORE.concat(options.ignore), ++ cwd: options.cwd ++ }); ++ const files = await Promise.all(paths.map(file => getFile(file, options.cwd))); ++ const ignores = reduceIgnore(files); ++ return getIsIgnoredPredecate(ignores, options.cwd); ++}; ++ ++var sync$7 = options => { ++ options = normalizeOptions$2(options); ++ const paths = out$3.sync('**/.gitignore', { ++ ignore: DEFAULT_IGNORE.concat(options.ignore), ++ cwd: options.cwd ++ }); ++ const files = paths.map(file => getFileSync(file, options.cwd)); ++ const ignores = reduceIgnore(files); ++ return getIsIgnoredPredecate(ignores, options.cwd); ++}; ++gitignore.sync = sync$7; ++ ++const { ++ Transform ++} = stream$5; ++ ++class ObjectTransform extends Transform { ++ constructor() { ++ super({ ++ objectMode: true ++ }); ++ } ++ ++} ++ ++class FilterStream extends ObjectTransform { ++ constructor(filter) { ++ super(); ++ this._filter = filter; ++ } ++ ++ _transform(data, encoding, callback) { ++ if (this._filter(data)) { ++ this.push(data); ++ } ++ ++ callback(); ++ } ++ ++} ++ ++class UniqueStream extends ObjectTransform { ++ constructor() { ++ super(); ++ this._pushed = new Set(); ++ } ++ ++ _transform(data, encoding, callback) { ++ if (!this._pushed.has(data)) { ++ this.push(data); ++ ++ this._pushed.add(data); ++ } ++ ++ callback(); ++ } ++ ++} ++ ++var streamUtils = { ++ FilterStream, ++ UniqueStream ++}; ++ ++const { ++ FilterStream: FilterStream$1, ++ UniqueStream: UniqueStream$1 ++} = streamUtils; ++ ++const DEFAULT_FILTER = () => false; ++ ++const isNegative = pattern => pattern[0] === '!'; ++ ++const assertPatternsInput$1 = patterns => { ++ if (!patterns.every(pattern => typeof pattern === 'string')) { ++ throw new TypeError('Patterns must be a string or an array of strings'); ++ } ++}; ++ ++const checkCwdOption = (options = {}) => { ++ if (!options.cwd) { ++ return; ++ } ++ ++ let stat; ++ ++ try { ++ stat = fs$2.statSync(options.cwd); ++ } catch (_) { ++ return; ++ } ++ ++ if (!stat.isDirectory()) { ++ throw new Error('The `cwd` option must be a path to a directory'); ++ } ++}; ++ ++const getPathString = p => p.stats instanceof fs$2.Stats ? p.path : p; ++ ++const generateGlobTasks = (patterns, taskOptions) => { ++ patterns = arrayUnion([].concat(patterns)); ++ assertPatternsInput$1(patterns); ++ checkCwdOption(taskOptions); ++ const globTasks = []; ++ taskOptions = Object.assign({ ++ ignore: [], ++ expandDirectories: true ++ }, taskOptions); ++ ++ for (const [index, pattern] of patterns.entries()) { ++ if (isNegative(pattern)) { ++ continue; ++ } ++ ++ const ignore = patterns.slice(index).filter(isNegative).map(pattern => pattern.slice(1)); ++ const options = Object.assign({}, taskOptions, { ++ ignore: taskOptions.ignore.concat(ignore) ++ }); ++ globTasks.push({ ++ pattern, ++ options ++ }); ++ } ++ ++ return globTasks; ++}; ++ ++const globDirs = (task, fn) => { ++ let options = {}; ++ ++ if (task.options.cwd) { ++ options.cwd = task.options.cwd; ++ } ++ ++ if (Array.isArray(task.options.expandDirectories)) { ++ options = Object.assign({}, options, { ++ files: task.options.expandDirectories ++ }); ++ } else if (typeof task.options.expandDirectories === 'object') { ++ options = Object.assign({}, options, {}, task.options.expandDirectories); ++ } ++ ++ return fn(task.pattern, options); ++}; ++ ++const getPattern = (task, fn) => task.options.expandDirectories ? globDirs(task, fn) : [task.pattern]; ++ ++const getFilterSync = options => { ++ return options && options.gitignore ? gitignore.sync({ ++ cwd: options.cwd, ++ ignore: options.ignore ++ }) : DEFAULT_FILTER; ++}; ++ ++const globToTask = task => glob => { ++ const { ++ options ++ } = task; ++ ++ if (options.ignore && Array.isArray(options.ignore) && options.expandDirectories) { ++ options.ignore = dirGlob.sync(options.ignore); ++ } ++ ++ return { ++ pattern: glob, ++ options ++ }; ++}; ++ ++var globby$1 = async (patterns, options) => { ++ const globTasks = generateGlobTasks(patterns, options); ++ ++ const getFilter = async () => { ++ return options && options.gitignore ? gitignore({ ++ cwd: options.cwd, ++ ignore: options.ignore ++ }) : DEFAULT_FILTER; ++ }; ++ ++ const getTasks = async () => { ++ const tasks = await Promise.all(globTasks.map(async task => { ++ const globs = await getPattern(task, dirGlob); ++ return Promise.all(globs.map(globToTask(task))); ++ })); ++ return arrayUnion(...tasks); ++ }; ++ ++ const [filter, tasks] = await Promise.all([getFilter(), getTasks()]); ++ const paths = await Promise.all(tasks.map(task => out$3(task.pattern, task.options))); ++ return arrayUnion(...paths).filter(path_ => !filter(getPathString(path_))); ++}; ++ ++var sync$8 = (patterns, options) => { ++ const globTasks = generateGlobTasks(patterns, options); ++ const tasks = globTasks.reduce((tasks, task) => { ++ const newTask = getPattern(task, dirGlob.sync).map(globToTask(task)); ++ return tasks.concat(newTask); ++ }, []); ++ const filter = getFilterSync(options); ++ return tasks.reduce((matches, task) => arrayUnion(matches, out$3.sync(task.pattern, task.options)), []).filter(path_ => !filter(path_)); ++}; ++ ++var stream$4 = (patterns, options) => { ++ const globTasks = generateGlobTasks(patterns, options); ++ const tasks = globTasks.reduce((tasks, task) => { ++ const newTask = getPattern(task, dirGlob.sync).map(globToTask(task)); ++ return tasks.concat(newTask); ++ }, []); ++ const filter = getFilterSync(options); ++ const filterStream = new FilterStream$1(p => !filter(p)); ++ const uniqueStream = new UniqueStream$1(); ++ return merge2_1(tasks.map(task => out$3.stream(task.pattern, task.options))).pipe(filterStream).pipe(uniqueStream); ++}; ++ ++var generateGlobTasks_1 = generateGlobTasks; ++ ++var hasMagic = (patterns, options) => [].concat(patterns).some(pattern => out$3.isDynamicPattern(pattern, options)); ++ ++var gitignore_1 = gitignore; ++globby$1.sync = sync$8; ++globby$1.stream = stream$4; ++globby$1.generateGlobTasks = generateGlobTasks_1; ++globby$1.hasMagic = hasMagic; ++globby$1.gitignore = gitignore_1; ++ ++const { ++ addLeadingComment: addLeadingComment$3, ++ addTrailingComment: addTrailingComment$3, ++ addDanglingComment: addDanglingComment$3, ++ getNextNonSpaceNonCommentCharacterIndex: getNextNonSpaceNonCommentCharacterIndex$2 ++} = utilShared; ++ ++function handleOwnLineComment(comment, text, options, ast, isLastComment) { ++ const { ++ precedingNode, ++ enclosingNode, ++ followingNode ++ } = comment; ++ return handleLastFunctionArgComments(text, precedingNode, enclosingNode, followingNode, comment, options) || handleMemberExpressionComments(enclosingNode, followingNode, comment) || handleIfStatementComments(text, precedingNode, enclosingNode, followingNode, comment, options) || handleWhileComments(text, precedingNode, enclosingNode, followingNode, comment, options) || handleTryStatementComments(enclosingNode, precedingNode, followingNode, comment) || handleClassComments(enclosingNode, precedingNode, followingNode, comment) || handleImportSpecifierComments(enclosingNode, comment) || handleForComments(enclosingNode, precedingNode, comment) || handleUnionTypeComments(precedingNode, enclosingNode, followingNode, comment) || handleOnlyComments(enclosingNode, ast, comment, isLastComment) || handleImportDeclarationComments(text, enclosingNode, precedingNode, comment, options) || handleAssignmentPatternComments(enclosingNode, comment) || handleMethodNameComments(text, enclosingNode, precedingNode, comment, options) || handleLabeledStatementComments(enclosingNode, comment); ++} ++ ++function handleEndOfLineComment(comment, text, options, ast, isLastComment) { ++ const { ++ precedingNode, ++ enclosingNode, ++ followingNode ++ } = comment; ++ return handleClosureTypeCastComments(followingNode, comment) || handleLastFunctionArgComments(text, precedingNode, enclosingNode, followingNode, comment, options) || handleConditionalExpressionComments(enclosingNode, precedingNode, followingNode, comment, text, options) || handleImportSpecifierComments(enclosingNode, comment) || handleIfStatementComments(text, precedingNode, enclosingNode, followingNode, comment, options) || handleWhileComments(text, precedingNode, enclosingNode, followingNode, comment, options) || handleTryStatementComments(enclosingNode, precedingNode, followingNode, comment) || handleClassComments(enclosingNode, precedingNode, followingNode, comment) || handleLabeledStatementComments(enclosingNode, comment) || handleCallExpressionComments(precedingNode, enclosingNode, comment) || handlePropertyComments(enclosingNode, comment) || handleOnlyComments(enclosingNode, ast, comment, isLastComment) || handleTypeAliasComments(enclosingNode, followingNode, comment) || handleVariableDeclaratorComments(enclosingNode, followingNode, comment); ++} ++ ++function handleRemainingComment(comment, text, options, ast, isLastComment) { ++ const { ++ precedingNode, ++ enclosingNode, ++ followingNode ++ } = comment; ++ ++ if (handleIfStatementComments(text, precedingNode, enclosingNode, followingNode, comment, options) || handleWhileComments(text, precedingNode, enclosingNode, followingNode, comment, options) || handleObjectPropertyAssignment(enclosingNode, precedingNode, comment) || handleCommentInEmptyParens(text, enclosingNode, comment, options) || handleMethodNameComments(text, enclosingNode, precedingNode, comment, options) || handleOnlyComments(enclosingNode, ast, comment, isLastComment) || handleCommentAfterArrowParams(text, enclosingNode, comment, options) || handleFunctionNameComments(text, enclosingNode, precedingNode, comment, options) || handleTSMappedTypeComments(text, enclosingNode, precedingNode, followingNode, comment) || handleBreakAndContinueStatementComments(enclosingNode, comment) || handleTSFunctionTrailingComments(text, enclosingNode, followingNode, comment, options)) { ++ return true; ++ } ++ ++ return false; ++} ++ ++function addBlockStatementFirstComment(node, comment) { ++ const body = node.body.filter(n => n.type !== "EmptyStatement"); ++ ++ if (body.length === 0) { ++ addDanglingComment$3(node, comment); ++ } else { ++ addLeadingComment$3(body[0], comment); ++ } ++} ++ ++function addBlockOrNotComment(node, comment) { ++ if (node.type === "BlockStatement") { ++ addBlockStatementFirstComment(node, comment); ++ } else { ++ addLeadingComment$3(node, comment); ++ } ++} ++ ++function handleClosureTypeCastComments(followingNode, comment) { ++ if (followingNode && isTypeCastComment(comment)) { ++ addLeadingComment$3(followingNode, comment); ++ return true; ++ } ++ ++ return false; ++} // There are often comments before the else clause of if statements like ++// ++// if (1) { ... } ++// // comment ++// else { ... } ++// ++// They are being attached as leading comments of the BlockExpression which ++// is not well printed. What we want is to instead move the comment inside ++// of the block and make it leadingComment of the first element of the block ++// or dangling comment of the block if there is nothing inside ++// ++// if (1) { ... } ++// else { ++// // comment ++// ... ++// } ++ ++ ++function handleIfStatementComments(text, precedingNode, enclosingNode, followingNode, comment, options) { ++ if (!enclosingNode || enclosingNode.type !== "IfStatement" || !followingNode) { ++ return false; ++ } // We unfortunately have no way using the AST or location of nodes to know ++ // if the comment is positioned before the condition parenthesis: ++ // if (a /* comment */) {} ++ // The only workaround I found is to look at the next character to see if ++ // it is a ). ++ ++ ++ const nextCharacter = util$1.getNextNonSpaceNonCommentCharacter(text, comment, options.locEnd); ++ ++ if (nextCharacter === ")") { ++ addTrailingComment$3(precedingNode, comment); ++ return true; ++ } // Comments before `else`: ++ // - treat as trailing comments of the consequent, if it's a BlockStatement ++ // - treat as a dangling comment otherwise ++ ++ ++ if (precedingNode === enclosingNode.consequent && followingNode === enclosingNode.alternate) { ++ if (precedingNode.type === "BlockStatement") { ++ addTrailingComment$3(precedingNode, comment); ++ } else { ++ addDanglingComment$3(enclosingNode, comment); ++ } ++ ++ return true; ++ } ++ ++ if (followingNode.type === "BlockStatement") { ++ addBlockStatementFirstComment(followingNode, comment); ++ return true; ++ } ++ ++ if (followingNode.type === "IfStatement") { ++ addBlockOrNotComment(followingNode.consequent, comment); ++ return true; ++ } // For comments positioned after the condition parenthesis in an if statement ++ // before the consequent without brackets on, such as ++ // if (a) /* comment */ true, ++ // we look at the next character to see if the following node ++ // is the consequent for the if statement ++ ++ ++ if (enclosingNode.consequent === followingNode) { ++ addLeadingComment$3(followingNode, comment); ++ return true; ++ } ++ ++ return false; ++} ++ ++function handleWhileComments(text, precedingNode, enclosingNode, followingNode, comment, options) { ++ if (!enclosingNode || enclosingNode.type !== "WhileStatement" || !followingNode) { ++ return false; ++ } // We unfortunately have no way using the AST or location of nodes to know ++ // if the comment is positioned before the condition parenthesis: ++ // while (a /* comment */) {} ++ // The only workaround I found is to look at the next character to see if ++ // it is a ). ++ ++ ++ const nextCharacter = util$1.getNextNonSpaceNonCommentCharacter(text, comment, options.locEnd); ++ ++ if (nextCharacter === ")") { ++ addTrailingComment$3(precedingNode, comment); ++ return true; ++ } ++ ++ if (followingNode.type === "BlockStatement") { ++ addBlockStatementFirstComment(followingNode, comment); ++ return true; ++ } ++ ++ return false; ++} // Same as IfStatement but for TryStatement ++ ++ ++function handleTryStatementComments(enclosingNode, precedingNode, followingNode, comment) { ++ if (!enclosingNode || enclosingNode.type !== "TryStatement" && enclosingNode.type !== "CatchClause" || !followingNode) { ++ return false; ++ } ++ ++ if (enclosingNode.type === "CatchClause" && precedingNode) { ++ addTrailingComment$3(precedingNode, comment); ++ return true; ++ } ++ ++ if (followingNode.type === "BlockStatement") { ++ addBlockStatementFirstComment(followingNode, comment); ++ return true; ++ } ++ ++ if (followingNode.type === "TryStatement") { ++ addBlockOrNotComment(followingNode.finalizer, comment); ++ return true; ++ } ++ ++ if (followingNode.type === "CatchClause") { ++ addBlockOrNotComment(followingNode.body, comment); ++ return true; ++ } ++ ++ return false; ++} ++ ++function handleMemberExpressionComments(enclosingNode, followingNode, comment) { ++ if (enclosingNode && (enclosingNode.type === "MemberExpression" || enclosingNode.type === "OptionalMemberExpression") && followingNode && followingNode.type === "Identifier") { ++ addLeadingComment$3(enclosingNode, comment); ++ return true; ++ } ++ ++ return false; ++} ++ ++function handleConditionalExpressionComments(enclosingNode, precedingNode, followingNode, comment, text, options) { ++ const isSameLineAsPrecedingNode = precedingNode && !util$1.hasNewlineInRange(text, options.locEnd(precedingNode), options.locStart(comment)); ++ ++ if ((!precedingNode || !isSameLineAsPrecedingNode) && enclosingNode && enclosingNode.type === "ConditionalExpression" && followingNode) { ++ addLeadingComment$3(followingNode, comment); ++ return true; ++ } ++ ++ return false; ++} ++ ++function handleObjectPropertyAssignment(enclosingNode, precedingNode, comment) { ++ if (enclosingNode && (enclosingNode.type === "ObjectProperty" || enclosingNode.type === "Property") && enclosingNode.shorthand && enclosingNode.key === precedingNode && enclosingNode.value.type === "AssignmentPattern") { ++ addTrailingComment$3(enclosingNode.value.left, comment); ++ return true; ++ } ++ ++ return false; ++} ++ ++function handleClassComments(enclosingNode, precedingNode, followingNode, comment) { ++ if (enclosingNode && (enclosingNode.type === "ClassDeclaration" || enclosingNode.type === "ClassExpression") && enclosingNode.decorators && enclosingNode.decorators.length > 0 && !(followingNode && followingNode.type === "Decorator")) { ++ if (!enclosingNode.decorators || enclosingNode.decorators.length === 0) { ++ addLeadingComment$3(enclosingNode, comment); ++ } else { ++ addTrailingComment$3(enclosingNode.decorators[enclosingNode.decorators.length - 1], comment); ++ } ++ ++ return true; ++ } ++ ++ return false; ++} ++ ++function handleMethodNameComments(text, enclosingNode, precedingNode, comment, options) { ++ // This is only needed for estree parsers (flow, typescript) to attach ++ // after a method name: ++ // obj = { fn /*comment*/() {} }; ++ if (enclosingNode && precedingNode && ( // "MethodDefinition" is handled in getCommentChildNodes ++ enclosingNode.type === "Property" || enclosingNode.type === "TSDeclareMethod" || enclosingNode.type === "TSAbstractMethodDefinition") && precedingNode.type === "Identifier" && enclosingNode.key === precedingNode && // special Property case: { key: /*comment*/(value) }; ++ // comment should be attached to value instead of key ++ util$1.getNextNonSpaceNonCommentCharacter(text, precedingNode, options.locEnd) !== ":") { ++ addTrailingComment$3(precedingNode, comment); ++ return true; ++ } // Print comments between decorators and class methods as a trailing comment ++ // on the decorator node instead of the method node ++ ++ ++ if (precedingNode && enclosingNode && precedingNode.type === "Decorator" && (enclosingNode.type === "ClassMethod" || enclosingNode.type === "ClassProperty" || enclosingNode.type === "TSAbstractClassProperty" || enclosingNode.type === "TSAbstractMethodDefinition" || enclosingNode.type === "TSDeclareMethod" || enclosingNode.type === "MethodDefinition")) { ++ addTrailingComment$3(precedingNode, comment); ++ return true; ++ } ++ ++ return false; ++} ++ ++function handleFunctionNameComments(text, enclosingNode, precedingNode, comment, options) { ++ if (util$1.getNextNonSpaceNonCommentCharacter(text, comment, options.locEnd) !== "(") { ++ return false; ++ } ++ ++ if (precedingNode && enclosingNode && (enclosingNode.type === "FunctionDeclaration" || enclosingNode.type === "FunctionExpression" || enclosingNode.type === "ClassMethod" || enclosingNode.type === "MethodDefinition" || enclosingNode.type === "ObjectMethod")) { ++ addTrailingComment$3(precedingNode, comment); ++ return true; ++ } ++ ++ return false; ++} ++ ++function handleCommentAfterArrowParams(text, enclosingNode, comment, options) { ++ if (!(enclosingNode && enclosingNode.type === "ArrowFunctionExpression")) { ++ return false; ++ } ++ ++ const index = getNextNonSpaceNonCommentCharacterIndex$2(text, comment, options.locEnd); ++ ++ if (text.slice(index, index + 2) === "=>") { ++ addDanglingComment$3(enclosingNode, comment); ++ return true; ++ } ++ ++ return false; ++} ++ ++function handleCommentInEmptyParens(text, enclosingNode, comment, options) { ++ if (util$1.getNextNonSpaceNonCommentCharacter(text, comment, options.locEnd) !== ")") { ++ return false; ++ } // Only add dangling comments to fix the case when no params are present, ++ // i.e. a function without any argument. ++ ++ ++ if (enclosingNode && (isRealFunctionLikeNode(enclosingNode) && // `params` vs `parameters` - see https://github.com/babel/babel/issues/9231 ++ (enclosingNode.params || enclosingNode.parameters).length === 0 || (enclosingNode.type === "CallExpression" || enclosingNode.type === "OptionalCallExpression" || enclosingNode.type === "NewExpression") && enclosingNode.arguments.length === 0)) { ++ addDanglingComment$3(enclosingNode, comment); ++ return true; ++ } ++ ++ if (enclosingNode && enclosingNode.type === "MethodDefinition" && enclosingNode.value.params.length === 0) { ++ addDanglingComment$3(enclosingNode.value, comment); ++ return true; ++ } ++ ++ return false; ++} ++ ++function handleLastFunctionArgComments(text, precedingNode, enclosingNode, followingNode, comment, options) { ++ // Flow function type definitions ++ if (precedingNode && precedingNode.type === "FunctionTypeParam" && enclosingNode && enclosingNode.type === "FunctionTypeAnnotation" && followingNode && followingNode.type !== "FunctionTypeParam") { ++ addTrailingComment$3(precedingNode, comment); ++ return true; ++ } // Real functions and TypeScript function type definitions ++ ++ ++ if (precedingNode && (precedingNode.type === "Identifier" || precedingNode.type === "AssignmentPattern") && enclosingNode && isRealFunctionLikeNode(enclosingNode) && util$1.getNextNonSpaceNonCommentCharacter(text, comment, options.locEnd) === ")") { ++ addTrailingComment$3(precedingNode, comment); ++ return true; ++ } ++ ++ if (enclosingNode && enclosingNode.type === "FunctionDeclaration" && followingNode && followingNode.type === "BlockStatement") { ++ const functionParamRightParenIndex = (() => { ++ if ((enclosingNode.params || enclosingNode.parameters).length !== 0) { ++ return util$1.getNextNonSpaceNonCommentCharacterIndexWithStartIndex(text, options.locEnd(util$1.getLast(enclosingNode.params || enclosingNode.parameters))); ++ } ++ ++ const functionParamLeftParenIndex = util$1.getNextNonSpaceNonCommentCharacterIndexWithStartIndex(text, options.locEnd(enclosingNode.id)); ++ return util$1.getNextNonSpaceNonCommentCharacterIndexWithStartIndex(text, functionParamLeftParenIndex + 1); ++ })(); ++ ++ if (options.locStart(comment) > functionParamRightParenIndex) { ++ addBlockStatementFirstComment(followingNode, comment); ++ return true; ++ } ++ } ++ ++ return false; ++} ++ ++function handleImportSpecifierComments(enclosingNode, comment) { ++ if (enclosingNode && enclosingNode.type === "ImportSpecifier") { ++ addLeadingComment$3(enclosingNode, comment); ++ return true; ++ } ++ ++ return false; ++} ++ ++function handleLabeledStatementComments(enclosingNode, comment) { ++ if (enclosingNode && enclosingNode.type === "LabeledStatement") { ++ addLeadingComment$3(enclosingNode, comment); ++ return true; ++ } ++ ++ return false; ++} ++ ++function handleBreakAndContinueStatementComments(enclosingNode, comment) { ++ if (enclosingNode && (enclosingNode.type === "ContinueStatement" || enclosingNode.type === "BreakStatement") && !enclosingNode.label) { ++ addTrailingComment$3(enclosingNode, comment); ++ return true; ++ } ++ ++ return false; ++} ++ ++function handleCallExpressionComments(precedingNode, enclosingNode, comment) { ++ if (enclosingNode && (enclosingNode.type === "CallExpression" || enclosingNode.type === "OptionalCallExpression") && precedingNode && enclosingNode.callee === precedingNode && enclosingNode.arguments.length > 0) { ++ addLeadingComment$3(enclosingNode.arguments[0], comment); ++ return true; ++ } ++ ++ return false; ++} ++ ++function handleUnionTypeComments(precedingNode, enclosingNode, followingNode, comment) { ++ if (enclosingNode && (enclosingNode.type === "UnionTypeAnnotation" || enclosingNode.type === "TSUnionType")) { ++ if (util$1.isNodeIgnoreComment(comment)) { ++ followingNode.prettierIgnore = true; ++ comment.unignore = true; ++ } ++ ++ if (precedingNode) { ++ addTrailingComment$3(precedingNode, comment); ++ return true; ++ } ++ ++ return false; ++ } ++ ++ if (followingNode && (followingNode.type === "UnionTypeAnnotation" || followingNode.type === "TSUnionType") && util$1.isNodeIgnoreComment(comment)) { ++ followingNode.types[0].prettierIgnore = true; ++ comment.unignore = true; ++ } ++ ++ return false; ++} ++ ++function handlePropertyComments(enclosingNode, comment) { ++ if (enclosingNode && (enclosingNode.type === "Property" || enclosingNode.type === "ObjectProperty")) { ++ addLeadingComment$3(enclosingNode, comment); ++ return true; ++ } ++ ++ return false; ++} ++ ++function handleOnlyComments(enclosingNode, ast, comment, isLastComment) { ++ // With Flow the enclosingNode is undefined so use the AST instead. ++ if (ast && ast.body && ast.body.length === 0) { ++ if (isLastComment) { ++ addDanglingComment$3(ast, comment); ++ } else { ++ addLeadingComment$3(ast, comment); ++ } ++ ++ return true; ++ } else if (enclosingNode && enclosingNode.type === "Program" && enclosingNode.body.length === 0 && enclosingNode.directives && enclosingNode.directives.length === 0) { ++ if (isLastComment) { ++ addDanglingComment$3(enclosingNode, comment); ++ } else { ++ addLeadingComment$3(enclosingNode, comment); ++ } ++ ++ return true; ++ } ++ ++ return false; ++} ++ ++function handleForComments(enclosingNode, precedingNode, comment) { ++ if (enclosingNode && (enclosingNode.type === "ForInStatement" || enclosingNode.type === "ForOfStatement")) { ++ addLeadingComment$3(enclosingNode, comment); ++ return true; ++ } ++ ++ return false; ++} ++ ++function handleImportDeclarationComments(text, enclosingNode, precedingNode, comment, options) { ++ if (precedingNode && precedingNode.type === "ImportSpecifier" && enclosingNode && enclosingNode.type === "ImportDeclaration" && util$1.hasNewline(text, options.locEnd(comment))) { ++ addTrailingComment$3(precedingNode, comment); ++ return true; ++ } ++ ++ return false; ++} ++ ++function handleAssignmentPatternComments(enclosingNode, comment) { ++ if (enclosingNode && enclosingNode.type === "AssignmentPattern") { ++ addLeadingComment$3(enclosingNode, comment); ++ return true; ++ } ++ ++ return false; ++} ++ ++function handleTypeAliasComments(enclosingNode, followingNode, comment) { ++ if (enclosingNode && enclosingNode.type === "TypeAlias") { ++ addLeadingComment$3(enclosingNode, comment); ++ return true; ++ } ++ ++ return false; ++} ++ ++function handleVariableDeclaratorComments(enclosingNode, followingNode, comment) { ++ if (enclosingNode && (enclosingNode.type === "VariableDeclarator" || enclosingNode.type === "AssignmentExpression") && followingNode && (followingNode.type === "ObjectExpression" || followingNode.type === "ArrayExpression" || followingNode.type === "TemplateLiteral" || followingNode.type === "TaggedTemplateExpression" || isBlockComment(comment))) { ++ addLeadingComment$3(followingNode, comment); ++ return true; ++ } ++ ++ return false; ++} ++ ++function handleTSFunctionTrailingComments(text, enclosingNode, followingNode, comment, options) { ++ if (!followingNode && enclosingNode && (enclosingNode.type === "TSMethodSignature" || enclosingNode.type === "TSDeclareFunction" || enclosingNode.type === "TSAbstractMethodDefinition") && util$1.getNextNonSpaceNonCommentCharacter(text, comment, options.locEnd) === ";") { ++ addTrailingComment$3(enclosingNode, comment); ++ return true; ++ } ++ ++ return false; ++} ++ ++function handleTSMappedTypeComments(text, enclosingNode, precedingNode, followingNode, comment) { ++ if (!enclosingNode || enclosingNode.type !== "TSMappedType") { ++ return false; ++ } ++ ++ if (followingNode && followingNode.type === "TSTypeParameter" && followingNode.name) { ++ addLeadingComment$3(followingNode.name, comment); ++ return true; ++ } ++ ++ if (precedingNode && precedingNode.type === "TSTypeParameter" && precedingNode.constraint) { ++ addTrailingComment$3(precedingNode.constraint, comment); ++ return true; ++ } ++ ++ return false; ++} ++ ++function isBlockComment(comment) { ++ return comment.type === "Block" || comment.type === "CommentBlock"; ++} ++ ++function hasLeadingComment(node, fn = () => true) { ++ if (node.leadingComments) { ++ return node.leadingComments.some(fn); ++ } ++ ++ if (node.comments) { ++ return node.comments.some(comment => comment.leading && fn(comment)); ++ } ++ ++ return false; ++} ++ ++function isRealFunctionLikeNode(node) { ++ return node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression" || node.type === "FunctionDeclaration" || node.type === "ObjectMethod" || node.type === "ClassMethod" || node.type === "TSDeclareFunction" || node.type === "TSCallSignatureDeclaration" || node.type === "TSConstructSignatureDeclaration" || node.type === "TSConstructSignatureDeclaration" || node.type === "TSMethodSignature" || node.type === "TSConstructorType" || node.type === "TSFunctionType" || node.type === "TSDeclareMethod"; ++} ++ ++function getGapRegex(enclosingNode) { ++ if (enclosingNode && enclosingNode.type !== "BinaryExpression" && enclosingNode.type !== "LogicalExpression") { ++ // Support degenerate single-element unions and intersections. ++ // E.g.: `type A = /* 1 */ & B` ++ return /^[\s(&|]*$/; ++ } ++} ++ ++function getCommentChildNodes(node, options) { ++ // Prevent attaching comments to FunctionExpression in this case: ++ // class Foo { ++ // bar() // comment ++ // { ++ // baz(); ++ // } ++ // } ++ if ((options.parser === "typescript" || options.parser === "flow") && node.type === "MethodDefinition" && node.value && node.value.type === "FunctionExpression" && node.value.params.length === 0 && !node.value.returnType && (!node.value.typeParameters || node.value.typeParameters.length === 0) && node.value.body) { ++ return [...(node.decorators || []), node.key, node.value.body]; ++ } ++} ++ ++function isTypeCastComment(comment) { ++ return isBlockComment(comment) && comment.value[0] === "*" && // TypeScript expects the type to be enclosed in curly brackets, however ++ // Closure Compiler accepts types in parens and even without any delimiters at all. ++ // That's why we just search for "@type". ++ /@type\b/.test(comment.value); ++} ++ ++var comments$1 = { ++ handleOwnLineComment, ++ handleEndOfLineComment, ++ handleRemainingComment, ++ hasLeadingComment, ++ isBlockComment, ++ isTypeCastComment, ++ getGapRegex, ++ getCommentChildNodes ++}; ++ ++const { ++ isBlockComment: isBlockComment$1, ++ hasLeadingComment: hasLeadingComment$1 ++} = comments$1; ++const { ++ builders: { ++ indent: indent$2, ++ join: join$2, ++ line: line$2, ++ hardline: hardline$3, ++ softline: softline$1, ++ literalline: literalline$1, ++ concat: concat$4, ++ group: group$1, ++ dedentToRoot: dedentToRoot$1 ++ }, ++ utils: { ++ mapDoc: mapDoc$2, ++ stripTrailingHardline: stripTrailingHardline$1 ++ } ++} = document; ++ ++function embed(path, print, textToDoc, options) { ++ const node = path.getValue(); ++ const parent = path.getParentNode(); ++ const parentParent = path.getParentNode(1); ++ ++ switch (node.type) { ++ case "TemplateLiteral": ++ { ++ const isCss = [isStyledJsx, isStyledComponents, isCssProp, isAngularComponentStyles].some(isIt => isIt(path)); ++ ++ if (isCss) { ++ // Get full template literal with expressions replaced by placeholders ++ const rawQuasis = node.quasis.map(q => q.value.raw); ++ let placeholderID = 0; ++ const text = rawQuasis.reduce((prevVal, currVal, idx) => { ++ if (idx === 0) { ++ return currVal; ++ } ++ ++ let specialSuffix = ""; // colons and whitespaces ++ ++ const trailingColons = currVal.match(/^(\s*)(:+)(\s*)/); ++ ++ if (trailingColons) { ++ const whitespaceBeforeColons = !!trailingColons[1]; ++ const numberOfColons = trailingColons[2].length; ++ const whitespaceAfterColons = !!trailingColons[3]; ++ ++ if (whitespaceAfterColons) ; else { ++ if (whitespaceBeforeColons) { ++ specialSuffix += "-whitespace"; ++ } ++ ++ specialSuffix += "-colon".repeat(numberOfColons); ++ currVal = "\uffff" + currVal.slice(trailingColons[0].length); ++ } ++ } ++ ++ const placeholder = `@prettier-placeholder${specialSuffix}-${placeholderID++}-id`; ++ return prevVal + placeholder + currVal; ++ }, ""); ++ const doc = textToDoc(text, { ++ parser: "css" ++ }); ++ return transformCssDoc(doc, path, print); ++ } ++ /* ++ * react-relay and graphql-tag ++ * graphql`...` ++ * graphql.experimental`...` ++ * gql`...` ++ * ++ * This intentionally excludes Relay Classic tags, as Prettier does not ++ * support Relay Classic formatting. ++ */ ++ ++ ++ if (isGraphQL(path)) { ++ const expressionDocs = node.expressions ? path.map(print, "expressions") : []; ++ const numQuasis = node.quasis.length; ++ ++ if (numQuasis === 1 && node.quasis[0].value.raw.trim() === "") { ++ return "``"; ++ } ++ ++ const parts = []; ++ ++ for (let i = 0; i < numQuasis; i++) { ++ const templateElement = node.quasis[i]; ++ const isFirst = i === 0; ++ const isLast = i === numQuasis - 1; ++ const text = templateElement.value.cooked; // Bail out if any of the quasis have an invalid escape sequence ++ // (which would make the `cooked` value be `null` or `undefined`) ++ ++ if (typeof text !== "string") { ++ return null; ++ } ++ ++ const lines = text.split("\n"); ++ const numLines = lines.length; ++ const expressionDoc = expressionDocs[i]; ++ const startsWithBlankLine = numLines > 2 && lines[0].trim() === "" && lines[1].trim() === ""; ++ const endsWithBlankLine = numLines > 2 && lines[numLines - 1].trim() === "" && lines[numLines - 2].trim() === ""; ++ const commentsAndWhitespaceOnly = lines.every(line => /^\s*(?:#[^\r\n]*)?$/.test(line)); // Bail out if an interpolation occurs within a comment. ++ ++ if (!isLast && /#[^\r\n]*$/.test(lines[numLines - 1])) { ++ return null; ++ } ++ ++ let doc = null; ++ ++ if (commentsAndWhitespaceOnly) { ++ doc = printGraphqlComments(lines); ++ } else { ++ doc = stripTrailingHardline$1(textToDoc(text, { ++ parser: "graphql" ++ })); ++ } ++ ++ if (doc) { ++ doc = escapeTemplateCharacters(doc, false); ++ ++ if (!isFirst && startsWithBlankLine) { ++ parts.push(""); ++ } ++ ++ parts.push(doc); ++ ++ if (!isLast && endsWithBlankLine) { ++ parts.push(""); ++ } ++ } else if (!isFirst && !isLast && startsWithBlankLine) { ++ parts.push(""); ++ } ++ ++ if (expressionDoc) { ++ parts.push(concat$4(["${", expressionDoc, "}"])); ++ } ++ } ++ ++ return concat$4(["`", indent$2(concat$4([hardline$3, join$2(hardline$3, parts)])), hardline$3, "`"]); ++ } ++ ++ const htmlParser = isHtml(path) ? "html" : isAngularComponentTemplate(path) ? "angular" : undefined; ++ ++ if (htmlParser) { ++ return printHtmlTemplateLiteral(path, print, textToDoc, htmlParser, options); ++ } ++ ++ break; ++ } ++ ++ case "TemplateElement": ++ { ++ /** ++ * md`...` ++ * markdown`...` ++ */ ++ if (parentParent && parentParent.type === "TaggedTemplateExpression" && parent.quasis.length === 1 && parentParent.tag.type === "Identifier" && (parentParent.tag.name === "md" || parentParent.tag.name === "markdown")) { ++ const text = parent.quasis[0].value.raw.replace(/((?:\\\\)*)\\`/g, (_, backslashes) => "\\".repeat(backslashes.length / 2) + "`"); ++ const indentation = getIndentation(text); ++ const hasIndent = indentation !== ""; ++ return concat$4([hasIndent ? indent$2(concat$4([softline$1, printMarkdown(text.replace(new RegExp(`^${indentation}`, "gm"), ""))])) : concat$4([literalline$1, dedentToRoot$1(printMarkdown(text))]), softline$1]); ++ } ++ ++ break; ++ } ++ } ++ ++ function printMarkdown(text) { ++ const doc = textToDoc(text, { ++ parser: "markdown", ++ __inJsTemplate: true ++ }); ++ return stripTrailingHardline$1(escapeTemplateCharacters(doc, true)); ++ } ++} ++ ++function getIndentation(str) { ++ const firstMatchedIndent = str.match(/^([^\S\n]*)\S/m); ++ return firstMatchedIndent === null ? "" : firstMatchedIndent[1]; ++} ++ ++function uncook(cookedValue) { ++ return cookedValue.replace(/([\\`]|\$\{)/g, "\\$1"); ++} ++ ++function escapeTemplateCharacters(doc, raw) { ++ return mapDoc$2(doc, currentDoc => { ++ if (!currentDoc.parts) { ++ return currentDoc; ++ } ++ ++ const parts = []; ++ currentDoc.parts.forEach(part => { ++ if (typeof part === "string") { ++ parts.push(raw ? part.replace(/(\\*)`/g, "$1$1\\`") : uncook(part)); ++ } else { ++ parts.push(part); ++ } ++ }); ++ return Object.assign({}, currentDoc, { ++ parts ++ }); ++ }); ++} ++ ++function transformCssDoc(quasisDoc, path, print) { ++ const parentNode = path.getValue(); ++ const isEmpty = parentNode.quasis.length === 1 && !parentNode.quasis[0].value.raw.trim(); ++ ++ if (isEmpty) { ++ return "``"; ++ } ++ ++ const expressionDocs = parentNode.expressions ? path.map(print, "expressions") : []; ++ const newDoc = replacePlaceholders(quasisDoc, expressionDocs); ++ /* istanbul ignore if */ ++ ++ if (!newDoc) { ++ throw new Error("Couldn't insert all the expressions"); ++ } ++ ++ return concat$4(["`", indent$2(concat$4([hardline$3, stripTrailingHardline$1(newDoc)])), softline$1, "`"]); ++} // Search all the placeholders in the quasisDoc tree ++// and replace them with the expression docs one by one ++// returns a new doc with all the placeholders replaced, ++// or null if it couldn't replace any expression ++ ++ ++function replacePlaceholders(quasisDoc, expressionDocs) { ++ if (!expressionDocs || !expressionDocs.length) { ++ return quasisDoc; ++ } ++ ++ const expressions = expressionDocs.slice(); ++ let replaceCounter = 0; ++ const newDoc = mapDoc$2(quasisDoc, doc => { ++ if (!doc || !doc.parts || !doc.parts.length) { ++ return doc; ++ } ++ ++ let { ++ parts ++ } = doc; ++ const atIndex = parts.indexOf("@"); ++ const placeholderIndex = atIndex + 1; ++ ++ if (atIndex > -1 && typeof parts[placeholderIndex] === "string" && parts[placeholderIndex].startsWith("prettier-placeholder")) { ++ // If placeholder is split, join it ++ const at = parts[atIndex]; ++ const placeholder = parts[placeholderIndex]; ++ const rest = parts.slice(placeholderIndex + 1); ++ parts = parts.slice(0, atIndex).concat([at + placeholder]).concat(rest); ++ } ++ ++ const atPlaceholderIndex = parts.findIndex(part => typeof part === "string" && part.startsWith("@prettier-placeholder")); ++ ++ if (atPlaceholderIndex > -1) { ++ const placeholder = parts[atPlaceholderIndex]; ++ const rest = parts.slice(atPlaceholderIndex + 1); ++ const placeholderMatch = placeholder.match(/@prettier-placeholder((?:-whitespace|-colon)*)-(.+)-id([\s\S]*)/); ++ const specialSuffix = placeholderMatch[1]; // colons and whitespaces ++ ++ const placeholderID = placeholderMatch[2]; // When the expression has a suffix appended, like: ++ // animation: linear ${time}s ease-out; ++ ++ let suffix = placeholderMatch[3]; ++ const expression = expressions[placeholderID]; ++ ++ if (specialSuffix) { ++ suffix = specialSuffix.replace(/-whitespace/g, " ").replace(/-colon/g, ":") + suffix.replace(/^\uffff/g, ""); ++ } ++ ++ replaceCounter++; ++ parts = parts.slice(0, atPlaceholderIndex).concat(["${", expression, "}" + suffix]).concat(rest); ++ } ++ ++ return Object.assign({}, doc, { ++ parts ++ }); ++ }); ++ return expressions.length === replaceCounter ? newDoc : null; ++} ++ ++function printGraphqlComments(lines) { ++ const parts = []; ++ let seenComment = false; ++ lines.map(textLine => textLine.trim()).forEach((textLine, i, array) => { ++ // Lines are either whitespace only, or a comment (with potential whitespace ++ // around it). Drop whitespace-only lines. ++ if (textLine === "") { ++ return; ++ } ++ ++ if (array[i - 1] === "" && seenComment) { ++ // If a non-first comment is preceded by a blank (whitespace only) line, ++ // add in a blank line. ++ parts.push(concat$4([hardline$3, textLine])); ++ } else { ++ parts.push(textLine); ++ } ++ ++ seenComment = true; ++ }); // If `lines` was whitespace only, return `null`. ++ ++ return parts.length === 0 ? null : join$2(hardline$3, parts); ++} ++/** ++ * Template literal in these contexts: ++ * ++ * css`` ++ * css.global`` ++ * css.resolve`` ++ */ ++ ++ ++function isStyledJsx(path) { ++ const node = path.getValue(); ++ const parent = path.getParentNode(); ++ const parentParent = path.getParentNode(1); ++ return parentParent && node.quasis && parent.type === "JSXExpressionContainer" && parentParent.type === "JSXElement" && parentParent.openingElement.name.name === "style" && parentParent.openingElement.attributes.some(attribute => attribute.name.name === "jsx") || parent && parent.type === "TaggedTemplateExpression" && parent.tag.type === "Identifier" && parent.tag.name === "css" || parent && parent.type === "TaggedTemplateExpression" && parent.tag.type === "MemberExpression" && parent.tag.object.name === "css" && (parent.tag.property.name === "global" || parent.tag.property.name === "resolve"); ++} ++/** ++ * Angular Components can have: ++ * - Inline HTML template ++ * - Inline CSS styles ++ * ++ * ...which are both within template literals somewhere ++ * inside of the Component decorator factory. ++ * ++ * E.g. ++ * @Component({ ++ * template: `
...
`, ++ * styles: [`h1 { color: blue; }`] ++ * }) ++ */ ++ ++ ++function isAngularComponentStyles(path) { ++ return path.match(node => node.type === "TemplateLiteral", (node, name) => node.type === "ArrayExpression" && name === "elements", (node, name) => (node.type === "Property" || node.type === "ObjectProperty") && node.key.type === "Identifier" && node.key.name === "styles" && name === "value", ...angularComponentObjectExpressionPredicates); ++} ++ ++function isAngularComponentTemplate(path) { ++ return path.match(node => node.type === "TemplateLiteral", (node, name) => (node.type === "Property" || node.type === "ObjectProperty") && node.key.type === "Identifier" && node.key.name === "template" && name === "value", ...angularComponentObjectExpressionPredicates); ++} ++ ++const angularComponentObjectExpressionPredicates = [(node, name) => node.type === "ObjectExpression" && name === "properties", (node, name) => node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "Component" && name === "arguments", (node, name) => node.type === "Decorator" && name === "expression"]; ++/** ++ * styled-components template literals ++ */ ++ ++function isStyledComponents(path) { ++ const parent = path.getParentNode(); ++ ++ if (!parent || parent.type !== "TaggedTemplateExpression") { ++ return false; ++ } ++ ++ const { ++ tag ++ } = parent; ++ ++ switch (tag.type) { ++ case "MemberExpression": ++ return (// styled.foo`` ++ isStyledIdentifier(tag.object) || // Component.extend`` ++ isStyledExtend(tag) ++ ); ++ ++ case "CallExpression": ++ return (// styled(Component)`` ++ isStyledIdentifier(tag.callee) || tag.callee.type === "MemberExpression" && (tag.callee.object.type === "MemberExpression" && ( // styled.foo.attrs({})`` ++ isStyledIdentifier(tag.callee.object.object) || // Component.extend.attrs({})`` ++ isStyledExtend(tag.callee.object)) || // styled(Component).attrs({})`` ++ tag.callee.object.type === "CallExpression" && isStyledIdentifier(tag.callee.object.callee)) ++ ); ++ ++ case "Identifier": ++ // css`` ++ return tag.name === "css"; ++ ++ default: ++ return false; ++ } ++} ++/** ++ * JSX element with CSS prop ++ */ ++ ++ ++function isCssProp(path) { ++ const parent = path.getParentNode(); ++ const parentParent = path.getParentNode(1); ++ return parentParent && parent.type === "JSXExpressionContainer" && parentParent.type === "JSXAttribute" && parentParent.name.type === "JSXIdentifier" && parentParent.name.name === "css"; ++} ++ ++function isStyledIdentifier(node) { ++ return node.type === "Identifier" && node.name === "styled"; ++} ++ ++function isStyledExtend(node) { ++ return /^[A-Z]/.test(node.object.name) && node.property.name === "extend"; ++} ++/* ++ * react-relay and graphql-tag ++ * graphql`...` ++ * graphql.experimental`...` ++ * gql`...` ++ * GraphQL comment block ++ * ++ * This intentionally excludes Relay Classic tags, as Prettier does not ++ * support Relay Classic formatting. ++ */ ++ ++ ++function isGraphQL(path) { ++ const node = path.getValue(); ++ const parent = path.getParentNode(); ++ return hasLanguageComment(node, "GraphQL") || parent && (parent.type === "TaggedTemplateExpression" && (parent.tag.type === "MemberExpression" && parent.tag.object.name === "graphql" && parent.tag.property.name === "experimental" || parent.tag.type === "Identifier" && (parent.tag.name === "gql" || parent.tag.name === "graphql")) || parent.type === "CallExpression" && parent.callee.type === "Identifier" && parent.callee.name === "graphql"); ++} ++ ++function hasLanguageComment(node, languageName) { ++ // This checks for a leading comment that is exactly `/* GraphQL */` ++ // In order to be in line with other implementations of this comment tag ++ // we will not trim the comment value and we will expect exactly one space on ++ // either side of the GraphQL string ++ // Also see ./clean.js ++ return hasLeadingComment$1(node, comment => isBlockComment$1(comment) && comment.value === ` ${languageName} `); ++} ++/** ++ * - html`...` ++ * - HTML comment block ++ */ ++ ++ ++function isHtml(path) { ++ return hasLanguageComment(path.getValue(), "HTML") || path.match(node => node.type === "TemplateLiteral", (node, name) => node.type === "TaggedTemplateExpression" && node.tag.type === "Identifier" && node.tag.name === "html" && name === "quasi"); ++} // The counter is needed to distinguish nested embeds. ++ ++ ++let htmlTemplateLiteralCounter = 0; ++ ++function printHtmlTemplateLiteral(path, print, textToDoc, parser, options) { ++ const node = path.getValue(); ++ const counter = htmlTemplateLiteralCounter; ++ htmlTemplateLiteralCounter = htmlTemplateLiteralCounter + 1 >>> 0; ++ ++ const composePlaceholder = index => `PRETTIER_HTML_PLACEHOLDER_${index}_${counter}_IN_JS`; ++ ++ const text = node.quasis.map((quasi, index, quasis) => index === quasis.length - 1 ? quasi.value.cooked : quasi.value.cooked + composePlaceholder(index)).join(""); ++ const expressionDocs = path.map(print, "expressions"); ++ ++ if (expressionDocs.length === 0 && text.trim().length === 0) { ++ return "``"; ++ } ++ ++ const placeholderRegex = new RegExp(composePlaceholder("(\\d+)"), "g"); ++ let topLevelCount = 0; ++ const contentDoc = mapDoc$2(stripTrailingHardline$1(textToDoc(text, { ++ parser, ++ ++ __onHtmlRoot(root) { ++ topLevelCount = root.children.length; ++ } ++ ++ })), doc => { ++ if (typeof doc !== "string") { ++ return doc; ++ } ++ ++ const parts = []; ++ const components = doc.split(placeholderRegex); ++ ++ for (let i = 0; i < components.length; i++) { ++ let component = components[i]; ++ ++ if (i % 2 === 0) { ++ if (component) { ++ component = uncook(component); ++ ++ if (options.embeddedInHtml) { ++ component = component.replace(/<\/(script)\b/gi, "<\\/$1"); ++ } ++ ++ parts.push(component); ++ } ++ ++ continue; ++ } ++ ++ const placeholderIndex = +component; ++ parts.push(concat$4(["${", group$1(expressionDocs[placeholderIndex]), "}"])); ++ } ++ ++ return concat$4(parts); ++ }); ++ const leadingWhitespace = /^\s/.test(text) ? " " : ""; ++ const trailingWhitespace = /\s$/.test(text) ? " " : ""; ++ const linebreak = options.htmlWhitespaceSensitivity === "ignore" ? hardline$3 : leadingWhitespace && trailingWhitespace ? line$2 : null; ++ ++ if (linebreak) { ++ return group$1(concat$4(["`", indent$2(concat$4([linebreak, group$1(contentDoc)])), linebreak, "`"])); ++ } ++ ++ return group$1(concat$4(["`", leadingWhitespace, topLevelCount > 1 ? indent$2(group$1(contentDoc)) : group$1(contentDoc), trailingWhitespace, "`"])); ++} ++ ++var embed_1 = embed; ++ ++function clean(ast, newObj, parent) { ++ ["range", "raw", "comments", "leadingComments", "trailingComments", "innerComments", "extra", "start", "end", "flags", "errors"].forEach(name => { ++ delete newObj[name]; ++ }); ++ ++ if (ast.loc && ast.loc.source === null) { ++ delete newObj.loc.source; ++ } ++ ++ if (ast.type === "BigIntLiteral") { ++ newObj.value = newObj.value.toLowerCase(); ++ } // We remove extra `;` and add them when needed ++ ++ ++ if (ast.type === "EmptyStatement") { ++ return null; ++ } // We move text around, including whitespaces and add {" "} ++ ++ ++ if (ast.type === "JSXText") { ++ return null; ++ } ++ ++ if (ast.type === "JSXExpressionContainer" && ast.expression.type === "Literal" && ast.expression.value === " ") { ++ return null; ++ } // (TypeScript) Ignore `static` in `constructor(static p) {}` ++ // and `export` in `constructor(export p) {}` ++ ++ ++ if (ast.type === "TSParameterProperty" && ast.accessibility === null && !ast.readonly) { ++ return { ++ type: "Identifier", ++ name: ast.parameter.name, ++ typeAnnotation: newObj.parameter.typeAnnotation, ++ decorators: newObj.decorators ++ }; ++ } // (TypeScript) ignore empty `specifiers` array ++ ++ ++ if (ast.type === "TSNamespaceExportDeclaration" && ast.specifiers && ast.specifiers.length === 0) { ++ delete newObj.specifiers; ++ } // We convert
to
++ ++ ++ if (ast.type === "JSXOpeningElement") { ++ delete newObj.selfClosing; ++ } ++ ++ if (ast.type === "JSXElement") { ++ delete newObj.closingElement; ++ } // We change {'key': value} into {key: value} ++ ++ ++ if ((ast.type === "Property" || ast.type === "ObjectProperty" || ast.type === "MethodDefinition" || ast.type === "ClassProperty" || ast.type === "TSPropertySignature" || ast.type === "ObjectTypeProperty") && typeof ast.key === "object" && ast.key && (ast.key.type === "Literal" || ast.key.type === "StringLiteral" || ast.key.type === "Identifier")) { ++ delete newObj.key; ++ } ++ ++ if (ast.type === "OptionalMemberExpression" && ast.optional === false) { ++ newObj.type = "MemberExpression"; ++ delete newObj.optional; ++ } // Remove raw and cooked values from TemplateElement when it's CSS ++ // styled-jsx ++ ++ ++ if (ast.type === "JSXElement" && ast.openingElement.name.name === "style" && ast.openingElement.attributes.some(attr => attr.name.name === "jsx")) { ++ const templateLiterals = newObj.children.filter(child => child.type === "JSXExpressionContainer" && child.expression.type === "TemplateLiteral").map(container => container.expression); ++ const quasis = templateLiterals.reduce((quasis, templateLiteral) => quasis.concat(templateLiteral.quasis), []); ++ quasis.forEach(q => delete q.value); ++ } // CSS template literals in css prop ++ ++ ++ if (ast.type === "JSXAttribute" && ast.name.name === "css" && ast.value.type === "JSXExpressionContainer" && ast.value.expression.type === "TemplateLiteral") { ++ newObj.value.expression.quasis.forEach(q => delete q.value); ++ } // Angular Components: Inline HTML template and Inline CSS styles ++ ++ ++ const expression = ast.expression || ast.callee; ++ ++ if (ast.type === "Decorator" && expression.type === "CallExpression" && expression.callee.name === "Component" && expression.arguments.length === 1) { ++ const astProps = ast.expression.arguments[0].properties; ++ newObj.expression.arguments[0].properties.forEach((prop, index) => { ++ let templateLiteral = null; ++ ++ switch (astProps[index].key.name) { ++ case "styles": ++ if (prop.value.type === "ArrayExpression") { ++ templateLiteral = prop.value.elements[0]; ++ } ++ ++ break; ++ ++ case "template": ++ if (prop.value.type === "TemplateLiteral") { ++ templateLiteral = prop.value; ++ } ++ ++ break; ++ } ++ ++ if (templateLiteral) { ++ templateLiteral.quasis.forEach(q => delete q.value); ++ } ++ }); ++ } // styled-components, graphql, markdown ++ ++ ++ if (ast.type === "TaggedTemplateExpression" && (ast.tag.type === "MemberExpression" || ast.tag.type === "Identifier" && (ast.tag.name === "gql" || ast.tag.name === "graphql" || ast.tag.name === "css" || ast.tag.name === "md" || ast.tag.name === "markdown" || ast.tag.name === "html") || ast.tag.type === "CallExpression")) { ++ newObj.quasi.quasis.forEach(quasi => delete quasi.value); ++ } ++ ++ if (ast.type === "TemplateLiteral") { ++ // This checks for a leading comment that is exactly `/* GraphQL */` ++ // In order to be in line with other implementations of this comment tag ++ // we will not trim the comment value and we will expect exactly one space on ++ // either side of the GraphQL string ++ // Also see ./embed.js ++ const hasLanguageComment = ast.leadingComments && ast.leadingComments.some(comment => comment.type === "CommentBlock" && ["GraphQL", "HTML"].some(languageName => comment.value === ` ${languageName} `)); ++ ++ if (hasLanguageComment || parent.type === "CallExpression" && parent.callee.name === "graphql") { ++ newObj.quasis.forEach(quasi => delete quasi.value); ++ } ++ } ++} ++ ++var clean_1 = clean; ++ ++const detectNewline = string => { ++ if (typeof string !== 'string') { ++ throw new TypeError('Expected a string'); ++ } ++ ++ const newlines = string.match(/(?:\r?\n)/g) || []; ++ ++ if (newlines.length === 0) { ++ return; ++ } ++ ++ const crlf = newlines.filter(newline => newline === '\r\n').length; ++ const lf = newlines.length - crlf; ++ return crlf > lf ? '\r\n' : '\n'; ++}; ++ ++var detectNewline_1 = detectNewline; ++ ++var graceful = string => typeof string === 'string' && detectNewline(string) || '\n'; ++detectNewline_1.graceful = graceful; ++ ++var build = createCommonjsModule(function (module, exports) { ++ ++ Object.defineProperty(exports, '__esModule', { ++ value: true ++ }); ++ exports.extract = extract; ++ exports.strip = strip; ++ exports.parse = parse; ++ exports.parseWithComments = parseWithComments; ++ exports.print = print; ++ ++ function _os() { ++ const data = os; ++ ++ _os = function () { ++ return data; ++ }; ++ ++ return data; ++ } ++ ++ function _detectNewline() { ++ const data = _interopRequireDefault(detectNewline_1); ++ ++ _detectNewline = function () { ++ return data; ++ }; ++ ++ return data; ++ } ++ ++ function _interopRequireDefault(obj) { ++ return obj && obj.__esModule ? obj : { ++ default: obj ++ }; ++ } ++ /** ++ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. ++ * ++ * This source code is licensed under the MIT license found in the ++ * LICENSE file in the root directory of this source tree. ++ */ ++ ++ ++ const commentEndRe = /\*\/$/; ++ const commentStartRe = /^\/\*\*/; ++ const docblockRe = /^\s*(\/\*\*?(.|\r?\n)*?\*\/)/; ++ const lineCommentRe = /(^|\s+)\/\/([^\r\n]*)/g; ++ const ltrimNewlineRe = /^(\r?\n)+/; ++ const multilineRe = /(?:^|\r?\n) *(@[^\r\n]*?) *\r?\n *(?![^@\r\n]*\/\/[^]*)([^@\r\n\s][^@\r\n]+?) *\r?\n/g; ++ const propertyRe = /(?:^|\r?\n) *@(\S+) *([^\r\n]*)/g; ++ const stringStartRe = /(\r?\n|^) *\* ?/g; ++ ++ function extract(contents) { ++ const match = contents.match(docblockRe); ++ return match ? match[0].trimLeft() : ''; ++ } ++ ++ function strip(contents) { ++ const match = contents.match(docblockRe); ++ return match && match[0] ? contents.substring(match[0].length) : contents; ++ } ++ ++ function parse(docblock) { ++ return parseWithComments(docblock).pragmas; ++ } ++ ++ function parseWithComments(docblock) { ++ const line = (0, _detectNewline().default)(docblock) || _os().EOL; ++ ++ docblock = docblock.replace(commentStartRe, '').replace(commentEndRe, '').replace(stringStartRe, '$1'); // Normalize multi-line directives ++ ++ let prev = ''; ++ ++ while (prev !== docblock) { ++ prev = docblock; ++ docblock = docblock.replace(multilineRe, `${line}$1 $2${line}`); ++ } ++ ++ docblock = docblock.replace(ltrimNewlineRe, '').trimRight(); ++ const result = Object.create(null); ++ const comments = docblock.replace(propertyRe, '').replace(ltrimNewlineRe, '').trimRight(); ++ let match; ++ ++ while (match = propertyRe.exec(docblock)) { ++ // strip linecomments from pragmas ++ const nextPragma = match[2].replace(lineCommentRe, ''); ++ ++ if (typeof result[match[1]] === 'string' || Array.isArray(result[match[1]])) { ++ result[match[1]] = [].concat(result[match[1]], nextPragma); ++ } else { ++ result[match[1]] = nextPragma; ++ } ++ } ++ ++ return { ++ comments, ++ pragmas: result ++ }; ++ } ++ ++ function print({ ++ comments = '', ++ pragmas = {} ++ }) { ++ const line = (0, _detectNewline().default)(comments) || _os().EOL; ++ ++ const head = '/**'; ++ const start = ' *'; ++ const tail = ' */'; ++ const keys = Object.keys(pragmas); ++ const printedObject = keys.map(key => printKeyValues(key, pragmas[key])).reduce((arr, next) => arr.concat(next), []).map(keyValue => start + ' ' + keyValue + line).join(''); ++ ++ if (!comments) { ++ if (keys.length === 0) { ++ return ''; ++ } ++ ++ if (keys.length === 1 && !Array.isArray(pragmas[keys[0]])) { ++ const value = pragmas[keys[0]]; ++ return `${head} ${printKeyValues(keys[0], value)[0]}${tail}`; ++ } ++ } ++ ++ const printedComments = comments.split(line).map(textLine => `${start} ${textLine}`).join(line) + line; ++ return head + line + (comments ? printedComments : '') + (comments && keys.length ? start + line : '') + printedObject + tail; ++ } ++ ++ function printKeyValues(key, valueOrArray) { ++ return [].concat(valueOrArray).map(value => `@${key} ${value}`.trim()); ++ } ++}); ++unwrapExports(build); ++var build_1 = build.extract; ++var build_2 = build.strip; ++var build_3 = build.parse; ++var build_4 = build.parseWithComments; ++var build_5 = build.print; ++ ++function hasPragma(text) { ++ const pragmas = Object.keys(build.parse(build.extract(text))); ++ return pragmas.includes("prettier") || pragmas.includes("format"); ++} ++ ++function insertPragma(text) { ++ const parsedDocblock = build.parseWithComments(build.extract(text)); ++ const pragmas = Object.assign({ ++ format: "" ++ }, parsedDocblock.pragmas); ++ const newDocblock = build.print({ ++ pragmas, ++ comments: parsedDocblock.comments.replace(/^(\s+?\r?\n)+/, "") // remove leading newlines ++ ++ }).replace(/(\r\n|\r)/g, "\n"); // normalise newlines (mitigate use of os.EOL by jest-docblock) ++ ++ const strippedText = build.strip(text); ++ const separatingNewlines = strippedText.startsWith("\n") ? "\n" : "\n\n"; ++ return newDocblock + separatingNewlines + strippedText; ++} ++ ++var pragma = { ++ hasPragma, ++ insertPragma ++}; ++ ++const { ++ getLast: getLast$1, ++ hasNewline: hasNewline$3, ++ hasNewlineInRange: hasNewlineInRange$2, ++ hasIgnoreComment: hasIgnoreComment$1, ++ hasNodeIgnoreComment: hasNodeIgnoreComment$1, ++ skipWhitespace: skipWhitespace$2 ++} = util$1; ++const isIdentifierName = utils$1.keyword.isIdentifierNameES5; // We match any whitespace except line terminators because ++// Flow annotation comments cannot be split across lines. For example: ++// ++// (this /* ++// : any */).foo = 5; ++// ++// is not picked up by Flow (see https://github.com/facebook/flow/issues/7050), so ++// removing the newline would create a type annotation that the user did not intend ++// to create. ++ ++const NON_LINE_TERMINATING_WHITE_SPACE = "(?:(?=.)\\s)"; ++const FLOW_SHORTHAND_ANNOTATION = new RegExp(`^${NON_LINE_TERMINATING_WHITE_SPACE}*:`); ++const FLOW_ANNOTATION = new RegExp(`^${NON_LINE_TERMINATING_WHITE_SPACE}*::`); ++ ++function hasFlowShorthandAnnotationComment(node) { ++ // https://flow.org/en/docs/types/comments/ ++ // Syntax example: const r = new (window.Request /*: Class */)(""); ++ return node.extra && node.extra.parenthesized && node.trailingComments && node.trailingComments[0].value.match(FLOW_SHORTHAND_ANNOTATION); ++} ++ ++function hasFlowAnnotationComment(comments) { ++ return comments && comments[0].value.match(FLOW_ANNOTATION); ++} ++ ++function hasNode(node, fn) { ++ if (!node || typeof node !== "object") { ++ return false; ++ } ++ ++ if (Array.isArray(node)) { ++ return node.some(value => hasNode(value, fn)); ++ } ++ ++ const result = fn(node); ++ return typeof result === "boolean" ? result : Object.keys(node).some(key => hasNode(node[key], fn)); ++} ++ ++function hasNakedLeftSide(node) { ++ return node.type === "AssignmentExpression" || node.type === "BinaryExpression" || node.type === "LogicalExpression" || node.type === "NGPipeExpression" || node.type === "ConditionalExpression" || node.type === "CallExpression" || node.type === "OptionalCallExpression" || node.type === "MemberExpression" || node.type === "OptionalMemberExpression" || node.type === "SequenceExpression" || node.type === "TaggedTemplateExpression" || node.type === "BindExpression" || node.type === "UpdateExpression" && !node.prefix || node.type === "TSAsExpression" || node.type === "TSNonNullExpression"; ++} ++ ++function getLeftSide(node) { ++ if (node.expressions) { ++ return node.expressions[0]; ++ } ++ ++ return node.left || node.test || node.callee || node.object || node.tag || node.argument || node.expression; ++} ++ ++function getLeftSidePathName(path, node) { ++ if (node.expressions) { ++ return ["expressions", 0]; ++ } ++ ++ if (node.left) { ++ return ["left"]; ++ } ++ ++ if (node.test) { ++ return ["test"]; ++ } ++ ++ if (node.object) { ++ return ["object"]; ++ } ++ ++ if (node.callee) { ++ return ["callee"]; ++ } ++ ++ if (node.tag) { ++ return ["tag"]; ++ } ++ ++ if (node.argument) { ++ return ["argument"]; ++ } ++ ++ if (node.expression) { ++ return ["expression"]; ++ } ++ ++ throw new Error("Unexpected node has no left side", node); ++} ++ ++const exportDeclarationTypes = new Set(["ExportDefaultDeclaration", "ExportDefaultSpecifier", "DeclareExportDeclaration", "ExportNamedDeclaration", "ExportAllDeclaration"]); ++ ++function isExportDeclaration(node) { ++ return node && exportDeclarationTypes.has(node.type); ++} ++ ++function getParentExportDeclaration(path) { ++ const parentNode = path.getParentNode(); ++ ++ if (path.getName() === "declaration" && isExportDeclaration(parentNode)) { ++ return parentNode; ++ } ++ ++ return null; ++} ++ ++function isLiteral(node) { ++ return node.type === "BooleanLiteral" || node.type === "DirectiveLiteral" || node.type === "Literal" || node.type === "NullLiteral" || node.type === "NumericLiteral" || node.type === "RegExpLiteral" || node.type === "StringLiteral" || node.type === "TemplateLiteral" || node.type === "TSTypeLiteral" || node.type === "JSXText"; ++} ++ ++function isNumericLiteral(node) { ++ return node.type === "NumericLiteral" || node.type === "Literal" && typeof node.value === "number"; ++} ++ ++function isStringLiteral(node) { ++ return node.type === "StringLiteral" || node.type === "Literal" && typeof node.value === "string"; ++} ++ ++function isObjectType(n) { ++ return n.type === "ObjectTypeAnnotation" || n.type === "TSTypeLiteral"; ++} ++ ++function isFunctionOrArrowExpression(node) { ++ return node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression"; ++} ++ ++function isFunctionOrArrowExpressionWithBody(node) { ++ return node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" && node.body.type === "BlockStatement"; ++} ++ ++function isTemplateLiteral(node) { ++ return node.type === "TemplateLiteral"; ++} // `inject` is used in AngularJS 1.x, `async` in Angular 2+ ++// example: https://docs.angularjs.org/guide/unit-testing#using-beforeall- ++ ++ ++function isAngularTestWrapper(node) { ++ return (node.type === "CallExpression" || node.type === "OptionalCallExpression") && node.callee.type === "Identifier" && (node.callee.name === "async" || node.callee.name === "inject" || node.callee.name === "fakeAsync"); ++} ++ ++function isJSXNode(node) { ++ return node.type === "JSXElement" || node.type === "JSXFragment"; ++} ++ ++function isTheOnlyJSXElementInMarkdown(options, path) { ++ if (options.parentParser !== "markdown" && options.parentParser !== "mdx") { ++ return false; ++ } ++ ++ const node = path.getNode(); ++ ++ if (!node.expression || !isJSXNode(node.expression)) { ++ return false; ++ } ++ ++ const parent = path.getParentNode(); ++ return parent.type === "Program" && parent.body.length === 1; ++} // Detect an expression node representing `{" "}` ++ ++ ++function isJSXWhitespaceExpression(node) { ++ return node.type === "JSXExpressionContainer" && isLiteral(node.expression) && node.expression.value === " " && !node.expression.comments; ++} ++ ++function isMemberExpressionChain(node) { ++ if (node.type !== "MemberExpression" && node.type !== "OptionalMemberExpression") { ++ return false; ++ } ++ ++ if (node.object.type === "Identifier") { ++ return true; ++ } ++ ++ return isMemberExpressionChain(node.object); ++} ++ ++function isGetterOrSetter(node) { ++ return node.kind === "get" || node.kind === "set"; ++} ++ ++function sameLocStart(nodeA, nodeB, options) { ++ return options.locStart(nodeA) === options.locStart(nodeB); ++} // TODO: This is a bad hack and we need a better way to distinguish between ++// arrow functions and otherwise ++ ++ ++function isFunctionNotation(node, options) { ++ return isGetterOrSetter(node) || sameLocStart(node, node.value, options); ++} // Hack to differentiate between the following two which have the same ast ++// type T = { method: () => void }; ++// type T = { method(): void }; ++ ++ ++function isObjectTypePropertyAFunction(node, options) { ++ return (node.type === "ObjectTypeProperty" || node.type === "ObjectTypeInternalSlot") && node.value.type === "FunctionTypeAnnotation" && !node.static && !isFunctionNotation(node, options); ++} // Hack to differentiate between the following two which have the same ast ++// declare function f(a): void; ++// var f: (a) => void; ++ ++ ++function isTypeAnnotationAFunction(node, options) { ++ return (node.type === "TypeAnnotation" || node.type === "TSTypeAnnotation") && node.typeAnnotation.type === "FunctionTypeAnnotation" && !node.static && !sameLocStart(node, node.typeAnnotation, options); ++} ++ ++function isBinaryish(node) { ++ return node.type === "BinaryExpression" || node.type === "LogicalExpression" || node.type === "NGPipeExpression"; ++} ++ ++function isMemberish(node) { ++ return node.type === "MemberExpression" || node.type === "OptionalMemberExpression" || node.type === "BindExpression" && node.object; ++} ++ ++function isSimpleFlowType(node) { ++ const flowTypeAnnotations = ["AnyTypeAnnotation", "NullLiteralTypeAnnotation", "GenericTypeAnnotation", "ThisTypeAnnotation", "NumberTypeAnnotation", "VoidTypeAnnotation", "EmptyTypeAnnotation", "MixedTypeAnnotation", "BooleanTypeAnnotation", "BooleanLiteralTypeAnnotation", "StringTypeAnnotation"]; ++ return node && flowTypeAnnotations.includes(node.type) && !(node.type === "GenericTypeAnnotation" && node.typeParameters); ++} ++ ++const unitTestRe = /^(skip|[fx]?(it|describe|test))$/; ++ ++function isSkipOrOnlyBlock(node) { ++ return (node.callee.type === "MemberExpression" || node.callee.type === "OptionalMemberExpression") && node.callee.object.type === "Identifier" && node.callee.property.type === "Identifier" && unitTestRe.test(node.callee.object.name) && (node.callee.property.name === "only" || node.callee.property.name === "skip"); ++} ++ ++function isUnitTestSetUp(n) { ++ const unitTestSetUpRe = /^(before|after)(Each|All)$/; ++ return n.callee.type === "Identifier" && unitTestSetUpRe.test(n.callee.name) && n.arguments.length === 1; ++} // eg; `describe("some string", (done) => {})` ++ ++ ++function isTestCall(n, parent) { ++ if (n.type !== "CallExpression") { ++ return false; ++ } ++ ++ if (n.arguments.length === 1) { ++ if (isAngularTestWrapper(n) && parent && isTestCall(parent)) { ++ return isFunctionOrArrowExpression(n.arguments[0]); ++ } ++ ++ if (isUnitTestSetUp(n)) { ++ return isAngularTestWrapper(n.arguments[0]); ++ } ++ } else if (n.arguments.length === 2 || n.arguments.length === 3) { ++ if ((n.callee.type === "Identifier" && unitTestRe.test(n.callee.name) || isSkipOrOnlyBlock(n)) && (isTemplateLiteral(n.arguments[0]) || isStringLiteral(n.arguments[0]))) { ++ // it("name", () => { ... }, 2500) ++ if (n.arguments[2] && !isNumericLiteral(n.arguments[2])) { ++ return false; ++ } ++ ++ return (n.arguments.length === 2 ? isFunctionOrArrowExpression(n.arguments[1]) : isFunctionOrArrowExpressionWithBody(n.arguments[1]) && n.arguments[1].params.length <= 1) || isAngularTestWrapper(n.arguments[1]); ++ } ++ } ++ ++ return false; ++} ++ ++function hasLeadingComment$2(node) { ++ return node.comments && node.comments.some(comment => comment.leading); ++} ++ ++function hasTrailingComment(node) { ++ return node.comments && node.comments.some(comment => comment.trailing); ++} ++ ++function isCallOrOptionalCallExpression(node) { ++ return node.type === "CallExpression" || node.type === "OptionalCallExpression"; ++} ++ ++function hasDanglingComments(node) { ++ return node.comments && node.comments.some(comment => !comment.leading && !comment.trailing); ++} ++/** identify if an angular expression seems to have side effects */ ++ ++ ++function hasNgSideEffect(path) { ++ return hasNode(path.getValue(), node => { ++ switch (node.type) { ++ case undefined: ++ return false; ++ ++ case "CallExpression": ++ case "OptionalCallExpression": ++ case "AssignmentExpression": ++ return true; ++ } ++ }); ++} ++ ++function isNgForOf(node, index, parentNode) { ++ return node.type === "NGMicrosyntaxKeyedExpression" && node.key.name === "of" && index === 1 && parentNode.body[0].type === "NGMicrosyntaxLet" && parentNode.body[0].value === null; ++} ++/** @param node {import("estree").TemplateLiteral} */ ++ ++ ++function isSimpleTemplateLiteral(node) { ++ if (node.expressions.length === 0) { ++ return false; ++ } ++ ++ return node.expressions.every(expr => { ++ // Disallow comments since printDocToString can't print them here ++ if (expr.comments) { ++ return false; ++ } // Allow `x` and `this` ++ ++ ++ if (expr.type === "Identifier" || expr.type === "ThisExpression") { ++ return true; ++ } // Allow `a.b.c`, `a.b[c]`, and `this.x.y` ++ ++ ++ if (expr.type === "MemberExpression" || expr.type === "OptionalMemberExpression") { ++ let head = expr; ++ ++ while (head.type === "MemberExpression" || head.type === "OptionalMemberExpression") { ++ if (head.property.type !== "Identifier" && head.property.type !== "Literal" && head.property.type !== "StringLiteral" && head.property.type !== "NumericLiteral") { ++ return false; ++ } ++ ++ head = head.object; ++ ++ if (head.comments) { ++ return false; ++ } ++ } ++ ++ if (head.type === "Identifier" || head.type === "ThisExpression") { ++ return true; ++ } ++ ++ return false; ++ } ++ ++ return false; ++ }); ++} ++ ++function getFlowVariance(path) { ++ if (!path.variance) { ++ return null; ++ } // Babel 7.0 currently uses variance node type, and flow should ++ // follow suit soon: ++ // https://github.com/babel/babel/issues/4722 ++ ++ ++ const variance = path.variance.kind || path.variance; ++ ++ switch (variance) { ++ case "plus": ++ return "+"; ++ ++ case "minus": ++ return "-"; ++ ++ default: ++ /* istanbul ignore next */ ++ return variance; ++ } ++} ++ ++function classPropMayCauseASIProblems(path) { ++ const node = path.getNode(); ++ ++ if (node.type !== "ClassProperty") { ++ return false; ++ } ++ ++ const name = node.key && node.key.name; // this isn't actually possible yet with most parsers available today ++ // so isn't properly tested yet. ++ ++ if ((name === "static" || name === "get" || name === "set") && !node.value && !node.typeAnnotation) { ++ return true; ++ } ++} ++ ++function classChildNeedsASIProtection(node) { ++ if (!node) { ++ return; ++ } ++ ++ if (node.static || node.accessibility // TypeScript ++ ) { ++ return false; ++ } ++ ++ if (!node.computed) { ++ const name = node.key && node.key.name; ++ ++ if (name === "in" || name === "instanceof") { ++ return true; ++ } ++ } ++ ++ switch (node.type) { ++ case "ClassProperty": ++ case "TSAbstractClassProperty": ++ return node.computed; ++ ++ case "MethodDefinition": // Flow ++ ++ case "TSAbstractMethodDefinition": // TypeScript ++ ++ case "ClassMethod": ++ case "ClassPrivateMethod": ++ { ++ // Babel ++ const isAsync = node.value ? node.value.async : node.async; ++ const isGenerator = node.value ? node.value.generator : node.generator; ++ ++ if (isAsync || node.kind === "get" || node.kind === "set") { ++ return false; ++ } ++ ++ if (node.computed || isGenerator) { ++ return true; ++ } ++ ++ return false; ++ } ++ ++ case "TSIndexSignature": ++ return true; ++ ++ default: ++ /* istanbul ignore next */ ++ return false; ++ } ++} ++ ++function getTypeScriptMappedTypeModifier(tokenNode, keyword) { ++ if (tokenNode === "+") { ++ return "+" + keyword; ++ } else if (tokenNode === "-") { ++ return "-" + keyword; ++ } ++ ++ return keyword; ++} ++ ++function hasNewlineBetweenOrAfterDecorators(node, options) { ++ return hasNewlineInRange$2(options.originalText, options.locStart(node.decorators[0]), options.locEnd(getLast$1(node.decorators))) || hasNewline$3(options.originalText, options.locEnd(getLast$1(node.decorators))); ++} // Only space, newline, carriage return, and tab are treated as whitespace ++// inside JSX. ++ ++ ++const jsxWhitespaceChars = " \n\r\t"; ++const matchJsxWhitespaceRegex = new RegExp("([" + jsxWhitespaceChars + "]+)"); ++const containsNonJsxWhitespaceRegex = new RegExp("[^" + jsxWhitespaceChars + "]"); // Meaningful if it contains non-whitespace characters, ++// or it contains whitespace without a new line. ++ ++function isMeaningfulJSXText(node) { ++ return isLiteral(node) && (containsNonJsxWhitespaceRegex.test(rawText(node)) || !/\n/.test(rawText(node))); ++} ++ ++function hasJsxIgnoreComment(path) { ++ const node = path.getValue(); ++ const parent = path.getParentNode(); ++ ++ if (!parent || !node || !isJSXNode(node) || !isJSXNode(parent)) { ++ return false; ++ } // Lookup the previous sibling, ignoring any empty JSXText elements ++ ++ ++ const index = parent.children.indexOf(node); ++ let prevSibling = null; ++ ++ for (let i = index; i > 0; i--) { ++ const candidate = parent.children[i - 1]; ++ ++ if (candidate.type === "JSXText" && !isMeaningfulJSXText(candidate)) { ++ continue; ++ } ++ ++ prevSibling = candidate; ++ break; ++ } ++ ++ return prevSibling && prevSibling.type === "JSXExpressionContainer" && prevSibling.expression.type === "JSXEmptyExpression" && prevSibling.expression.comments && prevSibling.expression.comments.find(comment => comment.value.trim() === "prettier-ignore"); ++} ++ ++function isEmptyJSXElement(node) { ++ if (node.children.length === 0) { ++ return true; ++ } ++ ++ if (node.children.length > 1) { ++ return false; ++ } // if there is one text child and does not contain any meaningful text ++ // we can treat the element as empty. ++ ++ ++ const child = node.children[0]; ++ return isLiteral(child) && !isMeaningfulJSXText(child); ++} ++ ++function hasPrettierIgnore(path) { ++ return hasIgnoreComment$1(path) || hasJsxIgnoreComment(path); ++} ++ ++function isLastStatement(path) { ++ const parent = path.getParentNode(); ++ ++ if (!parent) { ++ return true; ++ } ++ ++ const node = path.getValue(); ++ const body = (parent.body || parent.consequent).filter(stmt => stmt.type !== "EmptyStatement"); ++ return body && body[body.length - 1] === node; ++} ++ ++function isFlowAnnotationComment(text, typeAnnotation, options) { ++ const start = options.locStart(typeAnnotation); ++ const end = skipWhitespace$2(text, options.locEnd(typeAnnotation)); ++ return text.slice(start, start + 2) === "/*" && text.slice(end, end + 2) === "*/"; ++} ++ ++function hasLeadingOwnLineComment(text, node, options) { ++ if (isJSXNode(node)) { ++ return hasNodeIgnoreComment$1(node); ++ } ++ ++ const res = node.comments && node.comments.some(comment => comment.leading && hasNewline$3(text, options.locEnd(comment))); ++ return res; ++} // This recurses the return argument, looking for the first token ++// (the leftmost leaf node) and, if it (or its parents) has any ++// leadingComments, returns true (so it can be wrapped in parens). ++ ++ ++function returnArgumentHasLeadingComment(options, argument) { ++ if (hasLeadingOwnLineComment(options.originalText, argument, options)) { ++ return true; ++ } ++ ++ if (hasNakedLeftSide(argument)) { ++ let leftMost = argument; ++ let newLeftMost; ++ ++ while (newLeftMost = getLeftSide(leftMost)) { ++ leftMost = newLeftMost; ++ ++ if (hasLeadingOwnLineComment(options.originalText, leftMost, options)) { ++ return true; ++ } ++ } ++ } ++ ++ return false; ++} ++ ++function isStringPropSafeToCoerceToIdentifier(node, options) { ++ return isStringLiteral(node.key) && isIdentifierName(node.key.value) && options.parser !== "json" && // With `--strictPropertyInitialization`, TS treats properties with quoted names differently than unquoted ones. ++ // See https://github.com/microsoft/TypeScript/pull/20075 ++ !((options.parser === "typescript" || options.parser === "babel-ts") && node.type === "ClassProperty"); ++} ++ ++function isJestEachTemplateLiteral(node, parentNode) { ++ /** ++ * describe.each`table`(name, fn) ++ * describe.only.each`table`(name, fn) ++ * describe.skip.each`table`(name, fn) ++ * test.each`table`(name, fn) ++ * test.only.each`table`(name, fn) ++ * test.skip.each`table`(name, fn) ++ * ++ * Ref: https://github.com/facebook/jest/pull/6102 ++ */ ++ const jestEachTriggerRegex = /^[xf]?(describe|it|test)$/; ++ return parentNode.type === "TaggedTemplateExpression" && parentNode.quasi === node && parentNode.tag.type === "MemberExpression" && parentNode.tag.property.type === "Identifier" && parentNode.tag.property.name === "each" && (parentNode.tag.object.type === "Identifier" && jestEachTriggerRegex.test(parentNode.tag.object.name) || parentNode.tag.object.type === "MemberExpression" && parentNode.tag.object.property.type === "Identifier" && (parentNode.tag.object.property.name === "only" || parentNode.tag.object.property.name === "skip") && parentNode.tag.object.object.type === "Identifier" && jestEachTriggerRegex.test(parentNode.tag.object.object.name)); ++} ++ ++function templateLiteralHasNewLines(template) { ++ return template.quasis.some(quasi => quasi.value.raw.includes("\n")); ++} ++ ++function isTemplateOnItsOwnLine(n, text, options) { ++ return (n.type === "TemplateLiteral" && templateLiteralHasNewLines(n) || n.type === "TaggedTemplateExpression" && templateLiteralHasNewLines(n.quasi)) && !hasNewline$3(text, options.locStart(n), { ++ backwards: true ++ }); ++} ++ ++function needsHardlineAfterDanglingComment(node) { ++ if (!node.comments) { ++ return false; ++ } ++ ++ const lastDanglingComment = getLast$1(node.comments.filter(comment => !comment.leading && !comment.trailing)); ++ return lastDanglingComment && !comments$1.isBlockComment(lastDanglingComment); ++} // If we have nested conditional expressions, we want to print them in JSX mode ++// if there's at least one JSXElement somewhere in the tree. ++// ++// A conditional expression chain like this should be printed in normal mode, ++// because there aren't JSXElements anywhere in it: ++// ++// isA ? "A" : isB ? "B" : isC ? "C" : "Unknown"; ++// ++// But a conditional expression chain like this should be printed in JSX mode, ++// because there is a JSXElement in the last ConditionalExpression: ++// ++// isA ? "A" : isB ? "B" : isC ? "C" : Unknown; ++// ++// This type of ConditionalExpression chain is structured like this in the AST: ++// ++// ConditionalExpression { ++// test: ..., ++// consequent: ..., ++// alternate: ConditionalExpression { ++// test: ..., ++// consequent: ..., ++// alternate: ConditionalExpression { ++// test: ..., ++// consequent: ..., ++// alternate: ..., ++// } ++// } ++// } ++// ++// We want to traverse over that shape and convert it into a flat structure so ++// that we can find if there's a JSXElement somewhere inside. ++ ++ ++function getConditionalChainContents(node) { ++ // Given this code: ++ // ++ // // Using a ConditionalExpression as the consequent is uncommon, but should ++ // // be handled. ++ // A ? B : C ? D : E ? F ? G : H : I ++ // ++ // which has this AST: ++ // ++ // ConditionalExpression { ++ // test: Identifier(A), ++ // consequent: Identifier(B), ++ // alternate: ConditionalExpression { ++ // test: Identifier(C), ++ // consequent: Identifier(D), ++ // alternate: ConditionalExpression { ++ // test: Identifier(E), ++ // consequent: ConditionalExpression { ++ // test: Identifier(F), ++ // consequent: Identifier(G), ++ // alternate: Identifier(H), ++ // }, ++ // alternate: Identifier(I), ++ // } ++ // } ++ // } ++ // ++ // we should return this Array: ++ // ++ // [ ++ // Identifier(A), ++ // Identifier(B), ++ // Identifier(C), ++ // Identifier(D), ++ // Identifier(E), ++ // Identifier(F), ++ // Identifier(G), ++ // Identifier(H), ++ // Identifier(I) ++ // ]; ++ // ++ // This loses the information about whether each node was the test, ++ // consequent, or alternate, but we don't care about that here- we are only ++ // flattening this structure to find if there's any JSXElements inside. ++ const nonConditionalExpressions = []; ++ ++ function recurse(node) { ++ if (node.type === "ConditionalExpression") { ++ recurse(node.test); ++ recurse(node.consequent); ++ recurse(node.alternate); ++ } else { ++ nonConditionalExpressions.push(node); ++ } ++ } ++ ++ recurse(node); ++ return nonConditionalExpressions; ++} ++ ++function conditionalExpressionChainContainsJSX(node) { ++ return Boolean(getConditionalChainContents(node).find(isJSXNode)); ++} // Logic to check for args with multiple anonymous functions. For instance, ++// the following call should be split on multiple lines for readability: ++// source.pipe(map((x) => x + x), filter((x) => x % 2 === 0)) ++ ++ ++function isFunctionCompositionArgs(args) { ++ if (args.length <= 1) { ++ return false; ++ } ++ ++ let count = 0; ++ ++ for (const arg of args) { ++ if (isFunctionOrArrowExpression(arg)) { ++ count += 1; ++ ++ if (count > 1) { ++ return true; ++ } ++ } else if (isCallOrOptionalCallExpression(arg)) { ++ for (const childArg of arg.arguments) { ++ if (isFunctionOrArrowExpression(childArg)) { ++ return true; ++ } ++ } ++ } ++ } ++ ++ return false; ++} // Logic to determine if a call is a “long curried function call”. ++// See https://github.com/prettier/prettier/issues/1420. ++// ++// `connect(a, b, c)(d)` ++// In the above call expression, the second call is the parent node and the ++// first call is the current node. ++ ++ ++function isLongCurriedCallExpression(path) { ++ const node = path.getValue(); ++ const parent = path.getParentNode(); ++ return isCallOrOptionalCallExpression(node) && isCallOrOptionalCallExpression(parent) && parent.callee === node && node.arguments.length > parent.arguments.length && parent.arguments.length > 0; ++} ++/** ++ * @param {import('estree').Node} node ++ * @param {number} depth ++ * @returns {boolean} ++ */ ++ ++ ++function isSimpleCallArgument(node, depth) { ++ if (depth >= 2) { ++ return false; ++ } ++ ++ const isChildSimple = child => isSimpleCallArgument(child, depth + 1); ++ ++ const regexpPattern = node.type === "Literal" && node.regex && node.regex.pattern || node.type === "RegExpLiteral" && node.pattern; ++ ++ if (regexpPattern && regexpPattern.length > 5) { ++ return false; ++ } ++ ++ if (node.type === "Literal" || node.type === "BooleanLiteral" || node.type === "NullLiteral" || node.type === "NumericLiteral" || node.type === "StringLiteral" || node.type === "Identifier" || node.type === "ThisExpression" || node.type === "Super" || node.type === "BigIntLiteral" || node.type === "PrivateName" || node.type === "ArgumentPlaceholder" || node.type === "RegExpLiteral" || node.type === "Import") { ++ return true; ++ } ++ ++ if (node.type === "TemplateLiteral") { ++ return node.expressions.every(isChildSimple); ++ } ++ ++ if (node.type === "ObjectExpression") { ++ return node.properties.every(p => !p.computed && (p.shorthand || p.value && isChildSimple(p.value))); ++ } ++ ++ if (node.type === "ArrayExpression") { ++ return node.elements.every(isChildSimple); ++ } ++ ++ if (node.type === "CallExpression" || node.type === "OptionalCallExpression" || node.type === "NewExpression") { ++ return isSimpleCallArgument(node.callee, depth) && node.arguments.every(isChildSimple); ++ } ++ ++ if (node.type === "MemberExpression" || node.type === "OptionalMemberExpression") { ++ return isSimpleCallArgument(node.object, depth) && isSimpleCallArgument(node.property, depth); ++ } ++ ++ if (node.type === "UnaryExpression" && (node.operator === "!" || node.operator === "-")) { ++ return isSimpleCallArgument(node.argument, depth); ++ } ++ ++ if (node.type === "TSNonNullExpression") { ++ return isSimpleCallArgument(node.expression, depth); ++ } ++ ++ return false; ++} ++ ++function rawText(node) { ++ return node.extra ? node.extra.raw : node.raw; ++} ++ ++function identity$1(x) { ++ return x; ++} ++ ++function isTSXFile(options) { ++ return options.filepath && /\.tsx$/i.test(options.filepath); ++} ++ ++var utils$6 = { ++ classChildNeedsASIProtection, ++ classPropMayCauseASIProblems, ++ conditionalExpressionChainContainsJSX, ++ getFlowVariance, ++ getLeftSidePathName, ++ getParentExportDeclaration, ++ getTypeScriptMappedTypeModifier, ++ hasDanglingComments, ++ hasFlowAnnotationComment, ++ hasFlowShorthandAnnotationComment, ++ hasLeadingComment: hasLeadingComment$2, ++ hasLeadingOwnLineComment, ++ hasNakedLeftSide, ++ hasNewlineBetweenOrAfterDecorators, ++ hasNgSideEffect, ++ hasNode, ++ hasPrettierIgnore, ++ hasTrailingComment, ++ identity: identity$1, ++ isBinaryish, ++ isCallOrOptionalCallExpression, ++ isEmptyJSXElement, ++ isExportDeclaration, ++ isFlowAnnotationComment, ++ isFunctionCompositionArgs, ++ isFunctionNotation, ++ isFunctionOrArrowExpression, ++ isGetterOrSetter, ++ isJestEachTemplateLiteral, ++ isJSXNode, ++ isJSXWhitespaceExpression, ++ isLastStatement, ++ isLiteral, ++ isLongCurriedCallExpression, ++ isSimpleCallArgument, ++ isMeaningfulJSXText, ++ isMemberExpressionChain, ++ isMemberish, ++ isNgForOf, ++ isNumericLiteral, ++ isObjectType, ++ isObjectTypePropertyAFunction, ++ isSimpleFlowType, ++ isSimpleTemplateLiteral, ++ isStringLiteral, ++ isStringPropSafeToCoerceToIdentifier, ++ isTemplateOnItsOwnLine, ++ isTestCall, ++ isTheOnlyJSXElementInMarkdown, ++ isTSXFile, ++ isTypeAnnotationAFunction, ++ matchJsxWhitespaceRegex, ++ needsHardlineAfterDanglingComment, ++ rawText, ++ returnArgumentHasLeadingComment ++}; ++ ++const { ++ getLeftSidePathName: getLeftSidePathName$1, ++ hasFlowShorthandAnnotationComment: hasFlowShorthandAnnotationComment$1, ++ hasNakedLeftSide: hasNakedLeftSide$1, ++ hasNode: hasNode$1 ++} = utils$6; ++ ++function needsParens(path, options) { ++ const parent = path.getParentNode(); ++ ++ if (!parent) { ++ return false; ++ } ++ ++ const name = path.getName(); ++ const node = path.getNode(); // If the value of this path is some child of a Node and not a Node ++ // itself, then it doesn't need parentheses. Only Node objects (in ++ // fact, only Expression nodes) need parentheses. ++ ++ if (path.getValue() !== node) { ++ return false; ++ } // to avoid unexpected `}}` in HTML interpolations ++ ++ ++ if (options.__isInHtmlInterpolation && !options.bracketSpacing && endsWithRightBracket(node) && isFollowedByRightBracket(path)) { ++ return true; ++ } // Only statements don't need parentheses. ++ ++ ++ if (isStatement(node)) { ++ return false; ++ } ++ ++ if ( // Preserve parens if we have a Flow annotation comment, unless we're using the Flow ++ // parser. The Flow parser turns Flow comments into type annotation nodes in its ++ // AST, which we handle separately. ++ options.parser !== "flow" && hasFlowShorthandAnnotationComment$1(path.getValue())) { ++ return true; ++ } // Identifiers never need parentheses. ++ ++ ++ if (node.type === "Identifier") { ++ // ...unless those identifiers are embed placeholders. They might be substituted by complex ++ // expressions, so the parens around them should not be dropped. Example (JS-in-HTML-in-JS): ++ // let tpl = html``; ++ // If the inner JS formatter removes the parens, the expression might change its meaning: ++ // f((a + b) / 2) vs f(a + b / 2) ++ if (node.extra && node.extra.parenthesized && /^PRETTIER_HTML_PLACEHOLDER_\d+_\d+_IN_JS$/.test(node.name)) { ++ return true; ++ } ++ ++ return false; ++ } ++ ++ if (parent.type === "ParenthesizedExpression") { ++ return false; ++ } // Add parens around the extends clause of a class. It is needed for almost ++ // all expressions. ++ ++ ++ if ((parent.type === "ClassDeclaration" || parent.type === "ClassExpression") && parent.superClass === node && (node.type === "ArrowFunctionExpression" || node.type === "AssignmentExpression" || node.type === "AwaitExpression" || node.type === "BinaryExpression" || node.type === "ConditionalExpression" || node.type === "LogicalExpression" || node.type === "NewExpression" || node.type === "ObjectExpression" || node.type === "ParenthesizedExpression" || node.type === "SequenceExpression" || node.type === "TaggedTemplateExpression" || node.type === "UnaryExpression" || node.type === "UpdateExpression" || node.type === "YieldExpression")) { ++ return true; ++ } ++ ++ if (parent.type === "ExportDefaultDeclaration") { ++ return (// `export default function` or `export default class` can't be followed by ++ // anything after. So an expression like `export default (function(){}).toString()` ++ // needs to be followed by a parentheses ++ shouldWrapFunctionForExportDefault(path, options) || // `export default (foo, bar)` also needs parentheses ++ node.type === "SequenceExpression" ++ ); ++ } ++ ++ if (parent.type === "Decorator" && parent.expression === node) { ++ let hasCallExpression = false; ++ let hasMemberExpression = false; ++ let current = node; ++ ++ while (current) { ++ switch (current.type) { ++ case "MemberExpression": ++ hasMemberExpression = true; ++ current = current.object; ++ break; ++ ++ case "CallExpression": ++ if ( ++ /** @(x().y) */ ++ hasMemberExpression || ++ /** @(x().y()) */ ++ hasCallExpression) { ++ return true; ++ } ++ ++ hasCallExpression = true; ++ current = current.callee; ++ break; ++ ++ case "Identifier": ++ return false; ++ ++ default: ++ return true; ++ } ++ } ++ ++ return true; ++ } ++ ++ if (parent.type === "ArrowFunctionExpression" && parent.body === node && node.type !== "SequenceExpression" && // these have parens added anyway ++ util$1.startsWithNoLookaheadToken(node, ++ /* forbidFunctionClassAndDoExpr */ ++ false) || parent.type === "ExpressionStatement" && util$1.startsWithNoLookaheadToken(node, ++ /* forbidFunctionClassAndDoExpr */ ++ true)) { ++ return true; ++ } ++ ++ switch (node.type) { ++ case "SpreadElement": ++ case "SpreadProperty": ++ return parent.type === "MemberExpression" && name === "object" && parent.object === node; ++ ++ case "UpdateExpression": ++ if (parent.type === "UnaryExpression") { ++ return node.prefix && (node.operator === "++" && parent.operator === "+" || node.operator === "--" && parent.operator === "-"); ++ } ++ ++ // else fallthrough ++ ++ case "UnaryExpression": ++ switch (parent.type) { ++ case "UnaryExpression": ++ return node.operator === parent.operator && (node.operator === "+" || node.operator === "-"); ++ ++ case "BindExpression": ++ return true; ++ ++ case "MemberExpression": ++ case "OptionalMemberExpression": ++ return name === "object"; ++ ++ case "TaggedTemplateExpression": ++ return true; ++ ++ case "NewExpression": ++ case "CallExpression": ++ case "OptionalCallExpression": ++ return name === "callee"; ++ ++ case "BinaryExpression": ++ return parent.operator === "**" && name === "left"; ++ ++ case "TSNonNullExpression": ++ return true; ++ ++ default: ++ return false; ++ } ++ ++ case "BinaryExpression": ++ { ++ if (parent.type === "UpdateExpression") { ++ return true; ++ } ++ ++ const isLeftOfAForStatement = node => { ++ let i = 0; ++ ++ while (node) { ++ const parent = path.getParentNode(i++); ++ ++ if (!parent) { ++ return false; ++ } ++ ++ if (parent.type === "ForStatement" && parent.init === node) { ++ return true; ++ } ++ ++ node = parent; ++ } ++ ++ return false; ++ }; ++ ++ if (node.operator === "in" && isLeftOfAForStatement(node)) { ++ return true; ++ } ++ } ++ // fallthrough ++ ++ case "TSTypeAssertion": ++ case "TSAsExpression": ++ case "LogicalExpression": ++ switch (parent.type) { ++ case "ConditionalExpression": ++ return node.type === "TSAsExpression"; ++ ++ case "CallExpression": ++ case "NewExpression": ++ case "OptionalCallExpression": ++ return name === "callee"; ++ ++ case "ClassExpression": ++ case "ClassDeclaration": ++ return name === "superClass" && parent.superClass === node; ++ ++ case "TSTypeAssertion": ++ case "TaggedTemplateExpression": ++ case "UnaryExpression": ++ case "JSXSpreadAttribute": ++ case "SpreadElement": ++ case "SpreadProperty": ++ case "BindExpression": ++ case "AwaitExpression": ++ case "TSAsExpression": ++ case "TSNonNullExpression": ++ case "UpdateExpression": ++ return true; ++ ++ case "MemberExpression": ++ case "OptionalMemberExpression": ++ return name === "object"; ++ ++ case "AssignmentExpression": ++ return parent.left === node && (node.type === "TSTypeAssertion" || node.type === "TSAsExpression"); ++ ++ case "LogicalExpression": ++ if (node.type === "LogicalExpression") { ++ return parent.operator !== node.operator; ++ } ++ ++ // else fallthrough ++ ++ case "BinaryExpression": ++ { ++ if (!node.operator && node.type !== "TSTypeAssertion") { ++ return true; ++ } ++ ++ const po = parent.operator; ++ const pp = util$1.getPrecedence(po); ++ const no = node.operator; ++ const np = util$1.getPrecedence(no); ++ ++ if (pp > np) { ++ return true; ++ } ++ ++ if (pp === np && name === "right") { ++ assert.strictEqual(parent.right, node); ++ return true; ++ } ++ ++ if (pp === np && !util$1.shouldFlatten(po, no)) { ++ return true; ++ } ++ ++ if (pp < np && no === "%") { ++ return po === "+" || po === "-"; ++ } // Add parenthesis when working with bitwise operators ++ // It's not strictly needed but helps with code understanding ++ ++ ++ if (util$1.isBitwiseOperator(po)) { ++ return true; ++ } ++ ++ return false; ++ } ++ ++ default: ++ return false; ++ } ++ ++ case "SequenceExpression": ++ switch (parent.type) { ++ case "ReturnStatement": ++ return false; ++ ++ case "ForStatement": ++ // Although parentheses wouldn't hurt around sequence ++ // expressions in the head of for loops, traditional style ++ // dictates that e.g. i++, j++ should not be wrapped with ++ // parentheses. ++ return false; ++ ++ case "ExpressionStatement": ++ return name !== "expression"; ++ ++ case "ArrowFunctionExpression": ++ // We do need parentheses, but SequenceExpressions are handled ++ // specially when printing bodies of arrow functions. ++ return name !== "body"; ++ ++ default: ++ // Otherwise err on the side of overparenthesization, adding ++ // explicit exceptions above if this proves overzealous. ++ return true; ++ } ++ ++ case "YieldExpression": ++ if (parent.type === "UnaryExpression" || parent.type === "AwaitExpression" || parent.type === "TSAsExpression" || parent.type === "TSNonNullExpression") { ++ return true; ++ } ++ ++ // else fallthrough ++ ++ case "AwaitExpression": ++ switch (parent.type) { ++ case "TaggedTemplateExpression": ++ case "UnaryExpression": ++ case "BinaryExpression": ++ case "LogicalExpression": ++ case "SpreadElement": ++ case "SpreadProperty": ++ case "TSAsExpression": ++ case "TSNonNullExpression": ++ case "BindExpression": ++ return true; ++ ++ case "MemberExpression": ++ case "OptionalMemberExpression": ++ return name === "object"; ++ ++ case "NewExpression": ++ case "CallExpression": ++ case "OptionalCallExpression": ++ return name === "callee"; ++ ++ case "ConditionalExpression": ++ return parent.test === node; ++ ++ default: ++ return false; ++ } ++ ++ case "TSJSDocFunctionType": ++ case "TSConditionalType": ++ if (parent.type === "TSConditionalType" && node === parent.extendsType) { ++ return true; ++ } ++ ++ // fallthrough ++ ++ case "TSFunctionType": ++ case "TSConstructorType": ++ if (parent.type === "TSConditionalType" && node === parent.checkType) { ++ return true; ++ } ++ ++ // fallthrough ++ ++ case "TSUnionType": ++ case "TSIntersectionType": ++ if (parent.type === "TSUnionType" || parent.type === "TSIntersectionType") { ++ return true; ++ } ++ ++ // fallthrough ++ ++ case "TSTypeOperator": ++ case "TSInferType": ++ return parent.type === "TSArrayType" || parent.type === "TSOptionalType" || parent.type === "TSRestType" || parent.type === "TSIndexedAccessType" && node === parent.objectType || parent.type === "TSTypeOperator" || parent.type === "TSTypeAnnotation" && /^TSJSDoc/.test(path.getParentNode(1).type); ++ ++ case "ArrayTypeAnnotation": ++ return parent.type === "NullableTypeAnnotation"; ++ ++ case "IntersectionTypeAnnotation": ++ case "UnionTypeAnnotation": ++ return parent.type === "ArrayTypeAnnotation" || parent.type === "NullableTypeAnnotation" || parent.type === "IntersectionTypeAnnotation" || parent.type === "UnionTypeAnnotation"; ++ ++ case "NullableTypeAnnotation": ++ return parent.type === "ArrayTypeAnnotation"; ++ ++ case "FunctionTypeAnnotation": ++ { ++ const ancestor = parent.type === "NullableTypeAnnotation" ? path.getParentNode(1) : parent; ++ return ancestor.type === "UnionTypeAnnotation" || ancestor.type === "IntersectionTypeAnnotation" || ancestor.type === "ArrayTypeAnnotation" || // We should check ancestor's parent to know whether the parentheses ++ // are really needed, but since ??T doesn't make sense this check ++ // will almost never be true. ++ ancestor.type === "NullableTypeAnnotation"; ++ } ++ ++ case "StringLiteral": ++ case "NumericLiteral": ++ case "Literal": ++ if (typeof node.value === "string" && parent.type === "ExpressionStatement" && ( // TypeScript workaround for https://github.com/JamesHenry/typescript-estree/issues/2 ++ // See corresponding workaround in printer.js case: "Literal" ++ options.parser !== "typescript" && !parent.directive || options.parser === "typescript" && options.originalText.charAt(options.locStart(node) - 1) === "(")) { ++ // To avoid becoming a directive ++ const grandParent = path.getParentNode(1); ++ return grandParent.type === "Program" || grandParent.type === "BlockStatement"; ++ } ++ ++ return parent.type === "MemberExpression" && typeof node.value === "number" && name === "object" && parent.object === node; ++ ++ case "AssignmentExpression": ++ { ++ const grandParent = path.getParentNode(1); ++ ++ if (parent.type === "ArrowFunctionExpression" && parent.body === node) { ++ return true; ++ } else if (parent.type === "ClassProperty" && parent.key === node && parent.computed) { ++ return false; ++ } else if (parent.type === "TSPropertySignature" && parent.name === node) { ++ return false; ++ } else if (parent.type === "ForStatement" && (parent.init === node || parent.update === node)) { ++ return false; ++ } else if (parent.type === "ExpressionStatement") { ++ return node.left.type === "ObjectPattern"; ++ } else if (parent.type === "TSPropertySignature" && parent.key === node) { ++ return false; ++ } else if (parent.type === "AssignmentExpression") { ++ return false; ++ } else if (parent.type === "SequenceExpression" && grandParent && grandParent.type === "ForStatement" && (grandParent.init === parent || grandParent.update === parent)) { ++ return false; ++ } else if (parent.type === "Property" && parent.value === node) { ++ return false; ++ } else if (parent.type === "NGChainedExpression") { ++ return false; ++ } ++ ++ return true; ++ } ++ ++ case "ConditionalExpression": ++ switch (parent.type) { ++ case "TaggedTemplateExpression": ++ case "UnaryExpression": ++ case "SpreadElement": ++ case "SpreadProperty": ++ case "BinaryExpression": ++ case "LogicalExpression": ++ case "NGPipeExpression": ++ case "ExportDefaultDeclaration": ++ case "AwaitExpression": ++ case "JSXSpreadAttribute": ++ case "TSTypeAssertion": ++ case "TypeCastExpression": ++ case "TSAsExpression": ++ case "TSNonNullExpression": ++ return true; ++ ++ case "NewExpression": ++ case "CallExpression": ++ case "OptionalCallExpression": ++ return name === "callee"; ++ ++ case "ConditionalExpression": ++ return name === "test" && parent.test === node; ++ ++ case "MemberExpression": ++ case "OptionalMemberExpression": ++ return name === "object"; ++ ++ default: ++ return false; ++ } ++ ++ case "FunctionExpression": ++ switch (parent.type) { ++ case "NewExpression": ++ case "CallExpression": ++ case "OptionalCallExpression": ++ // Not always necessary, but it's clearer to the reader if IIFEs are wrapped in parentheses. ++ // Is necessary if it is `expression` of `ExpressionStatement`. ++ return name === "callee"; ++ ++ case "TaggedTemplateExpression": ++ return true; ++ // This is basically a kind of IIFE. ++ ++ default: ++ return false; ++ } ++ ++ case "ArrowFunctionExpression": ++ switch (parent.type) { ++ case "NewExpression": ++ case "CallExpression": ++ case "OptionalCallExpression": ++ return name === "callee"; ++ ++ case "MemberExpression": ++ case "OptionalMemberExpression": ++ return name === "object"; ++ ++ case "TSAsExpression": ++ case "BindExpression": ++ case "TaggedTemplateExpression": ++ case "UnaryExpression": ++ case "LogicalExpression": ++ case "BinaryExpression": ++ case "AwaitExpression": ++ case "TSTypeAssertion": ++ return true; ++ ++ case "ConditionalExpression": ++ return name === "test"; ++ ++ default: ++ return false; ++ } ++ ++ case "ClassExpression": ++ switch (parent.type) { ++ case "NewExpression": ++ return name === "callee" && parent.callee === node; ++ ++ default: ++ return false; ++ } ++ ++ case "OptionalMemberExpression": ++ case "OptionalCallExpression": ++ if (parent.type === "MemberExpression" && name === "object" || (parent.type === "CallExpression" || parent.type === "NewExpression") && name === "callee") { ++ return true; ++ } ++ ++ // fallthrough ++ ++ case "CallExpression": ++ case "MemberExpression": ++ case "TaggedTemplateExpression": ++ case "TSNonNullExpression": ++ if ((parent.type === "BindExpression" || parent.type === "NewExpression") && name === "callee") { ++ let object = node; ++ ++ while (object) { ++ switch (object.type) { ++ case "CallExpression": ++ case "OptionalCallExpression": ++ return true; ++ ++ case "MemberExpression": ++ case "OptionalMemberExpression": ++ case "BindExpression": ++ object = object.object; ++ break; ++ // tagged templates are basically member expressions from a grammar perspective ++ // see https://tc39.github.io/ecma262/#prod-MemberExpression ++ ++ case "TaggedTemplateExpression": ++ object = object.tag; ++ break; ++ ++ case "TSNonNullExpression": ++ object = object.expression; ++ break; ++ ++ default: ++ return false; ++ } ++ } ++ } ++ ++ return false; ++ ++ case "BindExpression": ++ return (parent.type === "BindExpression" || parent.type === "NewExpression") && name === "callee" || (parent.type === "MemberExpression" || parent.type === "OptionalMemberExpression") && name === "object"; ++ ++ case "NGPipeExpression": ++ if (parent.type === "NGRoot" || parent.type === "NGMicrosyntaxExpression" || parent.type === "ObjectProperty" || parent.type === "ArrayExpression" || (parent.type === "CallExpression" || parent.type === "OptionalCallExpression") && parent.arguments[name] === node || parent.type === "NGPipeExpression" && name === "right" || parent.type === "MemberExpression" && name === "property" || parent.type === "AssignmentExpression") { ++ return false; ++ } ++ ++ return true; ++ ++ case "JSXFragment": ++ case "JSXElement": ++ return name === "callee" || parent.type !== "ArrayExpression" && parent.type !== "ArrowFunctionExpression" && parent.type !== "AssignmentExpression" && parent.type !== "AssignmentPattern" && parent.type !== "BinaryExpression" && parent.type !== "CallExpression" && parent.type !== "NewExpression" && parent.type !== "ConditionalExpression" && parent.type !== "ExpressionStatement" && parent.type !== "JsExpressionRoot" && parent.type !== "JSXAttribute" && parent.type !== "JSXElement" && parent.type !== "JSXExpressionContainer" && parent.type !== "JSXFragment" && parent.type !== "LogicalExpression" && parent.type !== "ObjectProperty" && parent.type !== "OptionalCallExpression" && parent.type !== "Property" && parent.type !== "ReturnStatement" && parent.type !== "ThrowStatement" && parent.type !== "TypeCastExpression" && parent.type !== "VariableDeclarator" && parent.type !== "YieldExpression"; ++ ++ case "TypeAnnotation": ++ return name === "returnType" && parent.type === "ArrowFunctionExpression" && includesFunctionTypeInObjectType(node); ++ } ++ ++ return false; ++} ++ ++function isStatement(node) { ++ return node.type === "BlockStatement" || node.type === "BreakStatement" || node.type === "ClassBody" || node.type === "ClassDeclaration" || node.type === "ClassMethod" || node.type === "ClassProperty" || node.type === "ClassPrivateProperty" || node.type === "ContinueStatement" || node.type === "DebuggerStatement" || node.type === "DeclareClass" || node.type === "DeclareExportAllDeclaration" || node.type === "DeclareExportDeclaration" || node.type === "DeclareFunction" || node.type === "DeclareInterface" || node.type === "DeclareModule" || node.type === "DeclareModuleExports" || node.type === "DeclareVariable" || node.type === "DoWhileStatement" || node.type === "EnumDeclaration" || node.type === "ExportAllDeclaration" || node.type === "ExportDefaultDeclaration" || node.type === "ExportNamedDeclaration" || node.type === "ExpressionStatement" || node.type === "ForAwaitStatement" || node.type === "ForInStatement" || node.type === "ForOfStatement" || node.type === "ForStatement" || node.type === "FunctionDeclaration" || node.type === "IfStatement" || node.type === "ImportDeclaration" || node.type === "InterfaceDeclaration" || node.type === "LabeledStatement" || node.type === "MethodDefinition" || node.type === "ReturnStatement" || node.type === "SwitchStatement" || node.type === "ThrowStatement" || node.type === "TryStatement" || node.type === "TSDeclareFunction" || node.type === "TSEnumDeclaration" || node.type === "TSImportEqualsDeclaration" || node.type === "TSInterfaceDeclaration" || node.type === "TSModuleDeclaration" || node.type === "TSNamespaceExportDeclaration" || node.type === "TypeAlias" || node.type === "VariableDeclaration" || node.type === "WhileStatement" || node.type === "WithStatement"; ++} ++ ++function includesFunctionTypeInObjectType(node) { ++ return hasNode$1(node, n1 => n1.type === "ObjectTypeAnnotation" && hasNode$1(n1, n2 => n2.type === "FunctionTypeAnnotation" || undefined) || undefined); ++} ++ ++function endsWithRightBracket(node) { ++ switch (node.type) { ++ case "ObjectExpression": ++ return true; ++ ++ default: ++ return false; ++ } ++} ++ ++function isFollowedByRightBracket(path) { ++ const node = path.getValue(); ++ const parent = path.getParentNode(); ++ const name = path.getName(); ++ ++ switch (parent.type) { ++ case "NGPipeExpression": ++ if (typeof name === "number" && parent.arguments[name] === node && parent.arguments.length - 1 === name) { ++ return path.callParent(isFollowedByRightBracket); ++ } ++ ++ break; ++ ++ case "ObjectProperty": ++ if (name === "value") { ++ const parentParent = path.getParentNode(1); ++ return parentParent.properties[parentParent.properties.length - 1] === parent; ++ } ++ ++ break; ++ ++ case "BinaryExpression": ++ case "LogicalExpression": ++ if (name === "right") { ++ return path.callParent(isFollowedByRightBracket); ++ } ++ ++ break; ++ ++ case "ConditionalExpression": ++ if (name === "alternate") { ++ return path.callParent(isFollowedByRightBracket); ++ } ++ ++ break; ++ ++ case "UnaryExpression": ++ if (parent.prefix) { ++ return path.callParent(isFollowedByRightBracket); ++ } ++ ++ break; ++ } ++ ++ return false; ++} ++ ++function shouldWrapFunctionForExportDefault(path, options) { ++ const node = path.getValue(); ++ const parent = path.getParentNode(); ++ ++ if (node.type === "FunctionExpression" || node.type === "ClassExpression") { ++ return parent.type === "ExportDefaultDeclaration" || // in some cases the function is already wrapped ++ // (e.g. `export default (function() {})();`) ++ // in this case we don't need to add extra parens ++ !needsParens(path, options); ++ } ++ ++ if (!hasNakedLeftSide$1(node) || parent.type !== "ExportDefaultDeclaration" && needsParens(path, options)) { ++ return false; ++ } ++ ++ return path.call(childPath => shouldWrapFunctionForExportDefault(childPath, options), ...getLeftSidePathName$1(path, node)); ++} ++ ++var needsParens_1 = needsParens; ++ ++const { ++ builders: { ++ concat: concat$5, ++ join: join$3, ++ line: line$3 ++ } ++} = document; ++ ++function printHtmlBinding(path, options, print) { ++ const node = path.getValue(); ++ ++ if (options.__onHtmlBindingRoot && path.getName() === null) { ++ options.__onHtmlBindingRoot(node, options); ++ } ++ ++ if (node.type !== "File") { ++ return; ++ } ++ ++ if (options.__isVueForBindingLeft) { ++ return path.call(functionDeclarationPath => { ++ const { ++ params ++ } = functionDeclarationPath.getValue(); ++ return concat$5([params.length > 1 ? "(" : "", join$3(concat$5([",", line$3]), functionDeclarationPath.map(print, "params")), params.length > 1 ? ")" : ""]); ++ }, "program", "body", 0); ++ } ++ ++ if (options.__isVueSlotScope) { ++ return path.call(functionDeclarationPath => join$3(concat$5([",", line$3]), functionDeclarationPath.map(print, "params")), "program", "body", 0); ++ } ++} // based on https://github.com/prettier/prettier/blob/master/src/language-html/syntax-vue.js isVueEventBindingExpression() ++ ++ ++function isVueEventBindingExpression(node) { ++ switch (node.type) { ++ case "MemberExpression": ++ switch (node.property.type) { ++ case "Identifier": ++ case "NumericLiteral": ++ case "StringLiteral": ++ return isVueEventBindingExpression(node.object); ++ } ++ ++ return false; ++ ++ case "Identifier": ++ return true; ++ ++ default: ++ return false; ++ } ++} ++ ++var htmlBinding = { ++ isVueEventBindingExpression, ++ printHtmlBinding ++}; ++ ++function preprocess(ast, options) { ++ switch (options.parser) { ++ case "json": ++ case "json5": ++ case "json-stringify": ++ case "__js_expression": ++ case "__vue_expression": ++ return Object.assign({}, ast, { ++ type: options.parser.startsWith("__") ? "JsExpressionRoot" : "JsonRoot", ++ node: ast, ++ comments: [], ++ rootMarker: options.rootMarker ++ }); ++ ++ default: ++ return ast; ++ } ++} ++ ++var preprocess_1 = preprocess; ++ ++const { ++ shouldFlatten: shouldFlatten$1, ++ getNextNonSpaceNonCommentCharacter: getNextNonSpaceNonCommentCharacter$1, ++ hasNewline: hasNewline$4, ++ hasNewlineInRange: hasNewlineInRange$3, ++ getLast: getLast$2, ++ getStringWidth: getStringWidth$3, ++ printString: printString$1, ++ printNumber: printNumber$1, ++ hasIgnoreComment: hasIgnoreComment$2, ++ hasNodeIgnoreComment: hasNodeIgnoreComment$2, ++ getPenultimate: getPenultimate$1, ++ startsWithNoLookaheadToken: startsWithNoLookaheadToken$1, ++ getIndentSize: getIndentSize$2, ++ getPreferredQuote: getPreferredQuote$1 ++} = util$1; ++const { ++ isNextLineEmpty: isNextLineEmpty$2, ++ isNextLineEmptyAfterIndex: isNextLineEmptyAfterIndex$2, ++ getNextNonSpaceNonCommentCharacterIndex: getNextNonSpaceNonCommentCharacterIndex$3 ++} = utilShared; ++const { ++ insertPragma: insertPragma$1 ++} = pragma; ++const { ++ printHtmlBinding: printHtmlBinding$1, ++ isVueEventBindingExpression: isVueEventBindingExpression$1 ++} = htmlBinding; ++const { ++ classChildNeedsASIProtection: classChildNeedsASIProtection$1, ++ classPropMayCauseASIProblems: classPropMayCauseASIProblems$1, ++ conditionalExpressionChainContainsJSX: conditionalExpressionChainContainsJSX$1, ++ getFlowVariance: getFlowVariance$1, ++ getLeftSidePathName: getLeftSidePathName$2, ++ getParentExportDeclaration: getParentExportDeclaration$1, ++ getTypeScriptMappedTypeModifier: getTypeScriptMappedTypeModifier$1, ++ hasDanglingComments: hasDanglingComments$1, ++ hasFlowAnnotationComment: hasFlowAnnotationComment$1, ++ hasFlowShorthandAnnotationComment: hasFlowShorthandAnnotationComment$2, ++ hasLeadingComment: hasLeadingComment$3, ++ hasLeadingOwnLineComment: hasLeadingOwnLineComment$1, ++ hasNakedLeftSide: hasNakedLeftSide$2, ++ hasNewlineBetweenOrAfterDecorators: hasNewlineBetweenOrAfterDecorators$1, ++ hasNgSideEffect: hasNgSideEffect$1, ++ hasPrettierIgnore: hasPrettierIgnore$1, ++ hasTrailingComment: hasTrailingComment$1, ++ identity: identity$2, ++ isBinaryish: isBinaryish$1, ++ isCallOrOptionalCallExpression: isCallOrOptionalCallExpression$1, ++ isEmptyJSXElement: isEmptyJSXElement$1, ++ isExportDeclaration: isExportDeclaration$1, ++ isFlowAnnotationComment: isFlowAnnotationComment$1, ++ isFunctionCompositionArgs: isFunctionCompositionArgs$1, ++ isFunctionNotation: isFunctionNotation$1, ++ isFunctionOrArrowExpression: isFunctionOrArrowExpression$1, ++ isGetterOrSetter: isGetterOrSetter$1, ++ isJestEachTemplateLiteral: isJestEachTemplateLiteral$1, ++ isJSXNode: isJSXNode$1, ++ isJSXWhitespaceExpression: isJSXWhitespaceExpression$1, ++ isLastStatement: isLastStatement$1, ++ isLiteral: isLiteral$1, ++ isLongCurriedCallExpression: isLongCurriedCallExpression$1, ++ isMeaningfulJSXText: isMeaningfulJSXText$1, ++ isMemberExpressionChain: isMemberExpressionChain$1, ++ isMemberish: isMemberish$1, ++ isNgForOf: isNgForOf$1, ++ isNumericLiteral: isNumericLiteral$1, ++ isObjectType: isObjectType$1, ++ isObjectTypePropertyAFunction: isObjectTypePropertyAFunction$1, ++ isSimpleCallArgument: isSimpleCallArgument$1, ++ isSimpleFlowType: isSimpleFlowType$1, ++ isSimpleTemplateLiteral: isSimpleTemplateLiteral$1, ++ isStringLiteral: isStringLiteral$1, ++ isStringPropSafeToCoerceToIdentifier: isStringPropSafeToCoerceToIdentifier$1, ++ isTemplateOnItsOwnLine: isTemplateOnItsOwnLine$1, ++ isTestCall: isTestCall$1, ++ isTheOnlyJSXElementInMarkdown: isTheOnlyJSXElementInMarkdown$1, ++ isTSXFile: isTSXFile$1, ++ isTypeAnnotationAFunction: isTypeAnnotationAFunction$1, ++ matchJsxWhitespaceRegex: matchJsxWhitespaceRegex$1, ++ needsHardlineAfterDanglingComment: needsHardlineAfterDanglingComment$1, ++ rawText: rawText$1, ++ returnArgumentHasLeadingComment: returnArgumentHasLeadingComment$1 ++} = utils$6; ++const needsQuoteProps = new WeakMap(); ++const { ++ builders: { ++ concat: concat$6, ++ join: join$4, ++ line: line$4, ++ hardline: hardline$4, ++ softline: softline$2, ++ literalline: literalline$2, ++ group: group$2, ++ indent: indent$3, ++ align: align$1, ++ conditionalGroup: conditionalGroup$1, ++ fill: fill$3, ++ ifBreak: ifBreak$1, ++ breakParent: breakParent$2, ++ lineSuffixBoundary: lineSuffixBoundary$1, ++ addAlignmentToDoc: addAlignmentToDoc$2, ++ dedent: dedent$1 ++ }, ++ utils: { ++ willBreak: willBreak$1, ++ isLineNext: isLineNext$1, ++ isEmpty: isEmpty$1, ++ removeLines: removeLines$1 ++ }, ++ printer: { ++ printDocToString: printDocToString$2 ++ } ++} = document; ++let uid = 0; ++ ++function shouldPrintComma(options, level) { ++ level = level || "es5"; ++ ++ switch (options.trailingComma) { ++ case "all": ++ if (level === "all") { ++ return true; ++ } ++ ++ // fallthrough ++ ++ case "es5": ++ if (level === "es5") { ++ return true; ++ } ++ ++ // fallthrough ++ ++ case "none": ++ default: ++ return false; ++ } ++} ++ ++function genericPrint(path, options, printPath, args) { ++ const node = path.getValue(); ++ let needsParens = false; ++ const linesWithoutParens = printPathNoParens(path, options, printPath, args); ++ ++ if (!node || isEmpty$1(linesWithoutParens)) { ++ return linesWithoutParens; ++ } ++ ++ const parentExportDecl = getParentExportDeclaration$1(path); ++ const decorators = []; ++ ++ if (node.type === "ClassMethod" || node.type === "ClassPrivateMethod" || node.type === "ClassProperty" || node.type === "TSAbstractClassProperty" || node.type === "ClassPrivateProperty" || node.type === "MethodDefinition" || node.type === "TSAbstractMethodDefinition" || node.type === "TSDeclareMethod") ; else if (node.decorators && node.decorators.length > 0 && // If the parent node is an export declaration and the decorator ++ // was written before the export, the export will be responsible ++ // for printing the decorators. ++ !(parentExportDecl && options.locStart(parentExportDecl, { ++ ignoreDecorators: true ++ }) > options.locStart(node.decorators[0]))) { ++ const shouldBreak = node.type === "ClassExpression" || node.type === "ClassDeclaration" || hasNewlineBetweenOrAfterDecorators$1(node, options); ++ const separator = shouldBreak ? hardline$4 : line$4; ++ path.each(decoratorPath => { ++ let decorator = decoratorPath.getValue(); ++ ++ if (decorator.expression) { ++ decorator = decorator.expression; ++ } else { ++ decorator = decorator.callee; ++ } ++ ++ decorators.push(printPath(decoratorPath), separator); ++ }, "decorators"); ++ ++ if (parentExportDecl) { ++ decorators.unshift(hardline$4); ++ } ++ } else if (isExportDeclaration$1(node) && node.declaration && node.declaration.decorators && node.declaration.decorators.length > 0 && // Only print decorators here if they were written before the export, ++ // otherwise they are printed by the node.declaration ++ options.locStart(node, { ++ ignoreDecorators: true ++ }) > options.locStart(node.declaration.decorators[0])) { ++ // Export declarations are responsible for printing any decorators ++ // that logically apply to node.declaration. ++ path.each(decoratorPath => { ++ const decorator = decoratorPath.getValue(); ++ const prefix = decorator.type === "Decorator" ? "" : "@"; ++ decorators.push(prefix, printPath(decoratorPath), hardline$4); ++ }, "declaration", "decorators"); ++ } else { ++ // Nodes with decorators can't have parentheses, so we can avoid ++ // computing pathNeedsParens() except in this case. ++ needsParens = needsParens_1(path, options); ++ } ++ ++ const parts = []; ++ ++ if (needsParens) { ++ parts.unshift("("); ++ } ++ ++ parts.push(linesWithoutParens); ++ ++ if (needsParens) { ++ const node = path.getValue(); ++ ++ if (hasFlowShorthandAnnotationComment$2(node)) { ++ parts.push(" /*"); ++ parts.push(node.trailingComments[0].value.trimStart()); ++ parts.push("*/"); ++ node.trailingComments[0].printed = true; ++ } ++ ++ parts.push(")"); ++ } ++ ++ if (decorators.length > 0) { ++ return group$2(concat$6(decorators.concat(parts))); ++ } ++ ++ return concat$6(parts); ++} ++ ++function printDecorators(path, options, print) { ++ const node = path.getValue(); ++ return group$2(concat$6([join$4(line$4, path.map(print, "decorators")), hasNewlineBetweenOrAfterDecorators$1(node, options) ? hardline$4 : line$4])); ++} ++/** ++ * The following is the shared logic for ++ * ternary operators, namely ConditionalExpression ++ * and TSConditionalType ++ * @typedef {Object} OperatorOptions ++ * @property {() => Array} beforeParts - Parts to print before the `?`. ++ * @property {(breakClosingParen: boolean) => Array} afterParts - Parts to print after the conditional expression. ++ * @property {boolean} shouldCheckJsx - Whether to check for and print in JSX mode. ++ * @property {string} conditionalNodeType - The type of the conditional expression node, ie "ConditionalExpression" or "TSConditionalType". ++ * @property {string} consequentNodePropertyName - The property at which the consequent node can be found on the main node, eg "consequent". ++ * @property {string} alternateNodePropertyName - The property at which the alternate node can be found on the main node, eg "alternate". ++ * @property {string[]} testNodePropertyNames - The properties at which the test nodes can be found on the main node, eg "test". ++ * @param {FastPath} path - The path to the ConditionalExpression/TSConditionalType node. ++ * @param {Options} options - Prettier options ++ * @param {Function} print - Print function to call recursively ++ * @param {OperatorOptions} operatorOptions ++ * @returns Doc ++ */ ++ ++ ++function printTernaryOperator(path, options, print, operatorOptions) { ++ const node = path.getValue(); ++ const consequentNode = node[operatorOptions.consequentNodePropertyName]; ++ const alternateNode = node[operatorOptions.alternateNodePropertyName]; ++ const parts = []; // We print a ConditionalExpression in either "JSX mode" or "normal mode". ++ // See tests/jsx/conditional-expression.js for more info. ++ ++ let jsxMode = false; ++ const parent = path.getParentNode(); ++ const isParentTest = parent.type === operatorOptions.conditionalNodeType && operatorOptions.testNodePropertyNames.some(prop => parent[prop] === node); ++ let forceNoIndent = parent.type === operatorOptions.conditionalNodeType && !isParentTest; // Find the outermost non-ConditionalExpression parent, and the outermost ++ // ConditionalExpression parent. We'll use these to determine if we should ++ // print in JSX mode. ++ ++ let currentParent; ++ let previousParent; ++ let i = 0; ++ ++ do { ++ previousParent = currentParent || node; ++ currentParent = path.getParentNode(i); ++ i++; ++ } while (currentParent && currentParent.type === operatorOptions.conditionalNodeType && operatorOptions.testNodePropertyNames.every(prop => currentParent[prop] !== previousParent)); ++ ++ const firstNonConditionalParent = currentParent || parent; ++ const lastConditionalParent = previousParent; ++ ++ if (operatorOptions.shouldCheckJsx && (isJSXNode$1(node[operatorOptions.testNodePropertyNames[0]]) || isJSXNode$1(consequentNode) || isJSXNode$1(alternateNode) || conditionalExpressionChainContainsJSX$1(lastConditionalParent))) { ++ jsxMode = true; ++ forceNoIndent = true; // Even though they don't need parens, we wrap (almost) everything in ++ // parens when using ?: within JSX, because the parens are analogous to ++ // curly braces in an if statement. ++ ++ const wrap = doc => concat$6([ifBreak$1("(", ""), indent$3(concat$6([softline$2, doc])), softline$2, ifBreak$1(")", "")]); // The only things we don't wrap are: ++ // * Nested conditional expressions in alternates ++ // * null ++ // * undefined ++ ++ ++ const isNil = node => node.type === "NullLiteral" || node.type === "Literal" && node.value === null || node.type === "Identifier" && node.name === "undefined"; ++ ++ parts.push(" ? ", isNil(consequentNode) ? path.call(print, operatorOptions.consequentNodePropertyName) : wrap(path.call(print, operatorOptions.consequentNodePropertyName)), " : ", alternateNode.type === operatorOptions.conditionalNodeType || isNil(alternateNode) ? path.call(print, operatorOptions.alternateNodePropertyName) : wrap(path.call(print, operatorOptions.alternateNodePropertyName))); ++ } else { ++ // normal mode ++ const part = concat$6([line$4, "? ", consequentNode.type === operatorOptions.conditionalNodeType ? ifBreak$1("", "(") : "", align$1(2, path.call(print, operatorOptions.consequentNodePropertyName)), consequentNode.type === operatorOptions.conditionalNodeType ? ifBreak$1("", ")") : "", line$4, ": ", alternateNode.type === operatorOptions.conditionalNodeType ? path.call(print, operatorOptions.alternateNodePropertyName) : align$1(2, path.call(print, operatorOptions.alternateNodePropertyName))]); ++ parts.push(parent.type !== operatorOptions.conditionalNodeType || parent[operatorOptions.alternateNodePropertyName] === node || isParentTest ? part : options.useTabs ? dedent$1(indent$3(part)) : align$1(Math.max(0, options.tabWidth - 2), part)); ++ } // We want a whole chain of ConditionalExpressions to all ++ // break if any of them break. That means we should only group around the ++ // outer-most ConditionalExpression. ++ ++ ++ const maybeGroup = doc => parent === firstNonConditionalParent ? group$2(doc) : doc; // Break the closing paren to keep the chain right after it: ++ // (a ++ // ? b ++ // : c ++ // ).call() ++ ++ ++ const breakClosingParen = !jsxMode && (parent.type === "MemberExpression" || parent.type === "OptionalMemberExpression" || parent.type === "NGPipeExpression" && parent.left === node) && !parent.computed; ++ const result = maybeGroup(concat$6([].concat((testDoc => ++ /** ++ * a ++ * ? b ++ * : multiline ++ * test ++ * node ++ * ^^ align(2) ++ * ? d ++ * : e ++ */ ++ parent.type === operatorOptions.conditionalNodeType && parent[operatorOptions.alternateNodePropertyName] === node ? align$1(2, testDoc) : testDoc)(concat$6(operatorOptions.beforeParts())), forceNoIndent ? concat$6(parts) : indent$3(concat$6(parts)), operatorOptions.afterParts(breakClosingParen)))); ++ return isParentTest ? group$2(concat$6([indent$3(concat$6([softline$2, result])), softline$2])) : result; ++} ++ ++function printPathNoParens(path, options, print, args) { ++ const n = path.getValue(); ++ const semi = options.semi ? ";" : ""; ++ ++ if (!n) { ++ return ""; ++ } ++ ++ if (typeof n === "string") { ++ return n; ++ } ++ ++ const htmlBinding = printHtmlBinding$1(path, options, print); ++ ++ if (htmlBinding) { ++ return htmlBinding; ++ } ++ ++ let parts = []; ++ ++ switch (n.type) { ++ case "JsExpressionRoot": ++ return path.call(print, "node"); ++ ++ case "JsonRoot": ++ return concat$6([path.call(print, "node"), hardline$4]); ++ ++ case "File": ++ // Print @babel/parser's InterpreterDirective here so that ++ // leading comments on the `Program` node get printed after the hashbang. ++ if (n.program && n.program.interpreter) { ++ parts.push(path.call(programPath => programPath.call(print, "interpreter"), "program")); ++ } ++ ++ parts.push(path.call(print, "program")); ++ return concat$6(parts); ++ ++ case "Program": ++ // Babel 6 ++ if (n.directives) { ++ path.each(childPath => { ++ parts.push(print(childPath), semi, hardline$4); ++ ++ if (isNextLineEmpty$2(options.originalText, childPath.getValue(), options.locEnd)) { ++ parts.push(hardline$4); ++ } ++ }, "directives"); ++ } ++ ++ parts.push(path.call(bodyPath => { ++ return printStatementSequence(bodyPath, options, print); ++ }, "body")); ++ parts.push(comments.printDanglingComments(path, options, ++ /* sameIndent */ ++ true)); // Only force a trailing newline if there were any contents. ++ ++ if (n.body.length || n.comments) { ++ parts.push(hardline$4); ++ } ++ ++ return concat$6(parts); ++ // Babel extension. ++ ++ case "EmptyStatement": ++ return ""; ++ ++ case "ExpressionStatement": ++ // Detect Flow-parsed directives ++ if (n.directive) { ++ return concat$6([nodeStr(n.expression, options, true), semi]); ++ } ++ ++ if (options.parser === "__vue_event_binding") { ++ const parent = path.getParentNode(); ++ ++ if (parent.type === "Program" && parent.body.length === 1 && parent.body[0] === n) { ++ return concat$6([path.call(print, "expression"), isVueEventBindingExpression$1(n.expression) ? ";" : ""]); ++ } ++ } // Do not append semicolon after the only JSX element in a program ++ ++ ++ return concat$6([path.call(print, "expression"), isTheOnlyJSXElementInMarkdown$1(options, path) ? "" : semi]); ++ // Babel non-standard node. Used for Closure-style type casts. See postprocess.js. ++ ++ case "ParenthesizedExpression": ++ { ++ const shouldHug = !n.expression.comments; ++ ++ if (shouldHug) { ++ return concat$6(["(", path.call(print, "expression"), ")"]); ++ } ++ ++ return group$2(concat$6(["(", indent$3(concat$6([softline$2, path.call(print, "expression")])), softline$2, ")"])); ++ } ++ ++ case "AssignmentExpression": ++ return printAssignment(n.left, path.call(print, "left"), concat$6([" ", n.operator]), n.right, path.call(print, "right"), options); ++ ++ case "BinaryExpression": ++ case "LogicalExpression": ++ case "NGPipeExpression": ++ { ++ const parent = path.getParentNode(); ++ const parentParent = path.getParentNode(1); ++ const isInsideParenthesis = n !== parent.body && (parent.type === "IfStatement" || parent.type === "WhileStatement" || parent.type === "SwitchStatement" || parent.type === "DoWhileStatement"); ++ const parts = printBinaryishExpressions(path, print, options, ++ /* isNested */ ++ false, isInsideParenthesis); // if ( ++ // this.hasPlugin("dynamicImports") && this.lookahead().type === tt.parenLeft ++ // ) { ++ // ++ // looks super weird, we want to break the children if the parent breaks ++ // ++ // if ( ++ // this.hasPlugin("dynamicImports") && ++ // this.lookahead().type === tt.parenLeft ++ // ) { ++ ++ if (isInsideParenthesis) { ++ return concat$6(parts); ++ } // Break between the parens in ++ // unaries or in a member or specific call expression, i.e. ++ // ++ // ( ++ // a && ++ // b && ++ // c ++ // ).call() ++ ++ ++ if ((parent.type === "CallExpression" || parent.type === "OptionalCallExpression") && parent.callee === n || parent.type === "UnaryExpression" || (parent.type === "MemberExpression" || parent.type === "OptionalMemberExpression") && !parent.computed) { ++ return group$2(concat$6([indent$3(concat$6([softline$2, concat$6(parts)])), softline$2])); ++ } // Avoid indenting sub-expressions in some cases where the first sub-expression is already ++ // indented accordingly. We should indent sub-expressions where the first case isn't indented. ++ ++ ++ const shouldNotIndent = parent.type === "ReturnStatement" || parent.type === "ThrowStatement" || parent.type === "JSXExpressionContainer" && parentParent.type === "JSXAttribute" || n.operator !== "|" && parent.type === "JsExpressionRoot" || n.type !== "NGPipeExpression" && (parent.type === "NGRoot" && options.parser === "__ng_binding" || parent.type === "NGMicrosyntaxExpression" && parentParent.type === "NGMicrosyntax" && parentParent.body.length === 1) || n === parent.body && parent.type === "ArrowFunctionExpression" || n !== parent.body && parent.type === "ForStatement" || parent.type === "ConditionalExpression" && parentParent.type !== "ReturnStatement" && parentParent.type !== "ThrowStatement" && parentParent.type !== "CallExpression" && parentParent.type !== "OptionalCallExpression" || parent.type === "TemplateLiteral"; ++ const shouldIndentIfInlining = parent.type === "AssignmentExpression" || parent.type === "VariableDeclarator" || parent.type === "ClassProperty" || parent.type === "TSAbstractClassProperty" || parent.type === "ClassPrivateProperty" || parent.type === "ObjectProperty" || parent.type === "Property"; ++ const samePrecedenceSubExpression = isBinaryish$1(n.left) && shouldFlatten$1(n.operator, n.left.operator); ++ ++ if (shouldNotIndent || shouldInlineLogicalExpression(n) && !samePrecedenceSubExpression || !shouldInlineLogicalExpression(n) && shouldIndentIfInlining) { ++ return group$2(concat$6(parts)); ++ } ++ ++ if (parts.length === 0) { ++ return ""; ++ } // If the right part is a JSX node, we include it in a separate group to ++ // prevent it breaking the whole chain, so we can print the expression like: ++ // ++ // foo && bar && ( ++ // ++ // ++ // ++ // ) ++ ++ ++ const hasJSX = isJSXNode$1(n.right); ++ const rest = concat$6(hasJSX ? parts.slice(1, -1) : parts.slice(1)); ++ const groupId = Symbol("logicalChain-" + ++uid); ++ const chain = group$2(concat$6([// Don't include the initial expression in the indentation ++ // level. The first item is guaranteed to be the first ++ // left-most expression. ++ parts.length > 0 ? parts[0] : "", indent$3(rest)]), { ++ id: groupId ++ }); ++ ++ if (!hasJSX) { ++ return chain; ++ } ++ ++ const jsxPart = getLast$2(parts); ++ return group$2(concat$6([chain, ifBreak$1(indent$3(jsxPart), jsxPart, { ++ groupId ++ })])); ++ } ++ ++ case "AssignmentPattern": ++ return concat$6([path.call(print, "left"), " = ", path.call(print, "right")]); ++ ++ case "TSTypeAssertion": ++ { ++ const shouldBreakAfterCast = !(n.expression.type === "ArrayExpression" || n.expression.type === "ObjectExpression"); ++ const castGroup = group$2(concat$6(["<", indent$3(concat$6([softline$2, path.call(print, "typeAnnotation")])), softline$2, ">"])); ++ const exprContents = concat$6([ifBreak$1("("), indent$3(concat$6([softline$2, path.call(print, "expression")])), softline$2, ifBreak$1(")")]); ++ ++ if (shouldBreakAfterCast) { ++ return conditionalGroup$1([concat$6([castGroup, path.call(print, "expression")]), concat$6([castGroup, group$2(exprContents, { ++ shouldBreak: true ++ })]), concat$6([castGroup, path.call(print, "expression")])]); ++ } ++ ++ return group$2(concat$6([castGroup, path.call(print, "expression")])); ++ } ++ ++ case "OptionalMemberExpression": ++ case "MemberExpression": ++ { ++ const parent = path.getParentNode(); ++ let firstNonMemberParent; ++ let i = 0; ++ ++ do { ++ firstNonMemberParent = path.getParentNode(i); ++ i++; ++ } while (firstNonMemberParent && (firstNonMemberParent.type === "MemberExpression" || firstNonMemberParent.type === "OptionalMemberExpression" || firstNonMemberParent.type === "TSNonNullExpression")); ++ ++ const shouldInline = firstNonMemberParent && (firstNonMemberParent.type === "NewExpression" || firstNonMemberParent.type === "BindExpression" || firstNonMemberParent.type === "VariableDeclarator" && firstNonMemberParent.id.type !== "Identifier" || firstNonMemberParent.type === "AssignmentExpression" && firstNonMemberParent.left.type !== "Identifier") || n.computed || n.object.type === "Identifier" && n.property.type === "Identifier" && parent.type !== "MemberExpression" && parent.type !== "OptionalMemberExpression"; ++ return concat$6([path.call(print, "object"), shouldInline ? printMemberLookup(path, options, print) : group$2(indent$3(concat$6([softline$2, printMemberLookup(path, options, print)])))]); ++ } ++ ++ case "MetaProperty": ++ return concat$6([path.call(print, "meta"), ".", path.call(print, "property")]); ++ ++ case "BindExpression": ++ if (n.object) { ++ parts.push(path.call(print, "object")); ++ } ++ ++ parts.push(group$2(indent$3(concat$6([softline$2, printBindExpressionCallee(path, options, print)])))); ++ return concat$6(parts); ++ ++ case "Identifier": ++ { ++ return concat$6([n.name, printOptionalToken(path), printTypeAnnotation(path, options, print)]); ++ } ++ ++ case "V8IntrinsicIdentifier": ++ return concat$6(["%", n.name]); ++ ++ case "SpreadElement": ++ case "SpreadElementPattern": ++ case "RestProperty": ++ case "SpreadProperty": ++ case "SpreadPropertyPattern": ++ case "RestElement": ++ case "ObjectTypeSpreadProperty": ++ return concat$6(["...", path.call(print, "argument"), printTypeAnnotation(path, options, print)]); ++ ++ case "FunctionDeclaration": ++ case "FunctionExpression": ++ parts.push(printFunctionDeclaration(path, print, options)); ++ ++ if (!n.body) { ++ parts.push(semi); ++ } ++ ++ return concat$6(parts); ++ ++ case "ArrowFunctionExpression": ++ { ++ if (n.async) { ++ parts.push("async "); ++ } ++ ++ if (shouldPrintParamsWithoutParens(path, options)) { ++ parts.push(path.call(print, "params", 0)); ++ } else { ++ parts.push(group$2(concat$6([printFunctionParams(path, print, options, ++ /* expandLast */ ++ args && (args.expandLastArg || args.expandFirstArg), ++ /* printTypeParams */ ++ true), printReturnType(path, print, options)]))); ++ } ++ ++ const dangling = comments.printDanglingComments(path, options, ++ /* sameIndent */ ++ true, comment => { ++ const nextCharacter = getNextNonSpaceNonCommentCharacterIndex$3(options.originalText, comment, options.locEnd); ++ return options.originalText.slice(nextCharacter, nextCharacter + 2) === "=>"; ++ }); ++ ++ if (dangling) { ++ parts.push(" ", dangling); ++ } ++ ++ parts.push(" =>"); ++ const body = path.call(bodyPath => print(bodyPath, args), "body"); // We want to always keep these types of nodes on the same line ++ // as the arrow. ++ ++ if (!hasLeadingOwnLineComment$1(options.originalText, n.body, options) && (n.body.type === "ArrayExpression" || n.body.type === "ObjectExpression" || n.body.type === "BlockStatement" || isJSXNode$1(n.body) || isTemplateOnItsOwnLine$1(n.body, options.originalText, options) || n.body.type === "ArrowFunctionExpression" || n.body.type === "DoExpression")) { ++ return group$2(concat$6([concat$6(parts), " ", body])); ++ } // We handle sequence expressions as the body of arrows specially, ++ // so that the required parentheses end up on their own lines. ++ ++ ++ if (n.body.type === "SequenceExpression") { ++ return group$2(concat$6([concat$6(parts), group$2(concat$6([" (", indent$3(concat$6([softline$2, body])), softline$2, ")"]))])); ++ } // if the arrow function is expanded as last argument, we are adding a ++ // level of indentation and need to add a softline to align the closing ) ++ // with the opening (, or if it's inside a JSXExpression (e.g. an attribute) ++ // we should align the expression's closing } with the line with the opening {. ++ ++ ++ const shouldAddSoftLine = (args && args.expandLastArg || path.getParentNode().type === "JSXExpressionContainer") && !(n.comments && n.comments.length); ++ const printTrailingComma = args && args.expandLastArg && shouldPrintComma(options, "all"); // In order to avoid confusion between ++ // a => a ? a : a ++ // a <= a ? a : a ++ ++ const shouldAddParens = n.body.type === "ConditionalExpression" && !startsWithNoLookaheadToken$1(n.body, ++ /* forbidFunctionAndClass */ ++ false); ++ return group$2(concat$6([concat$6(parts), group$2(concat$6([indent$3(concat$6([line$4, shouldAddParens ? ifBreak$1("", "(") : "", body, shouldAddParens ? ifBreak$1("", ")") : ""])), shouldAddSoftLine ? concat$6([ifBreak$1(printTrailingComma ? "," : ""), softline$2]) : ""]))])); ++ } ++ ++ case "YieldExpression": ++ parts.push("yield"); ++ ++ if (n.delegate) { ++ parts.push("*"); ++ } ++ ++ if (n.argument) { ++ parts.push(" ", path.call(print, "argument")); ++ } ++ ++ return concat$6(parts); ++ ++ case "AwaitExpression": ++ { ++ parts.push("await ", path.call(print, "argument")); ++ const parent = path.getParentNode(); ++ ++ if ((parent.type === "CallExpression" || parent.type === "OptionalCallExpression") && parent.callee === n || (parent.type === "MemberExpression" || parent.type === "OptionalMemberExpression") && parent.object === n) { ++ return group$2(concat$6([indent$3(concat$6([softline$2, concat$6(parts)])), softline$2])); ++ } ++ ++ return concat$6(parts); ++ } ++ ++ case "ImportSpecifier": ++ if (n.importKind) { ++ parts.push(path.call(print, "importKind"), " "); ++ } ++ ++ parts.push(path.call(print, "imported")); ++ ++ if (n.local && n.local.name !== n.imported.name) { ++ parts.push(" as ", path.call(print, "local")); ++ } ++ ++ return concat$6(parts); ++ ++ case "ExportSpecifier": ++ parts.push(path.call(print, "local")); ++ ++ if (n.exported && n.exported.name !== n.local.name) { ++ parts.push(" as ", path.call(print, "exported")); ++ } ++ ++ return concat$6(parts); ++ ++ case "ImportNamespaceSpecifier": ++ parts.push("* as "); ++ parts.push(path.call(print, "local")); ++ return concat$6(parts); ++ ++ case "ImportDefaultSpecifier": ++ return path.call(print, "local"); ++ ++ case "TSExportAssignment": ++ return concat$6(["export = ", path.call(print, "expression"), semi]); ++ ++ case "ExportDefaultDeclaration": ++ case "ExportNamedDeclaration": ++ return printExportDeclaration(path, options, print); ++ ++ case "ExportAllDeclaration": ++ parts.push("export "); ++ ++ if (n.exportKind === "type") { ++ parts.push("type "); ++ } ++ ++ parts.push("* "); ++ ++ if (n.exported) { ++ parts.push("as ", path.call(print, "exported"), " "); ++ } ++ ++ parts.push("from ", path.call(print, "source"), semi); ++ return concat$6(parts); ++ ++ case "ExportNamespaceSpecifier": ++ case "ExportDefaultSpecifier": ++ return path.call(print, "exported"); ++ ++ case "ImportDeclaration": ++ { ++ parts.push("import "); ++ ++ if (n.importKind && n.importKind !== "value") { ++ parts.push(n.importKind + " "); ++ } ++ ++ const standalones = []; ++ const grouped = []; ++ ++ if (n.specifiers && n.specifiers.length > 0) { ++ path.each(specifierPath => { ++ const value = specifierPath.getValue(); ++ ++ if (value.type === "ImportDefaultSpecifier" || value.type === "ImportNamespaceSpecifier") { ++ standalones.push(print(specifierPath)); ++ } else { ++ grouped.push(print(specifierPath)); ++ } ++ }, "specifiers"); ++ ++ if (standalones.length > 0) { ++ parts.push(join$4(", ", standalones)); ++ } ++ ++ if (standalones.length > 0 && grouped.length > 0) { ++ parts.push(", "); ++ } ++ ++ if (grouped.length === 1 && standalones.length === 0 && n.specifiers && !n.specifiers.some(node => node.comments)) { ++ parts.push(concat$6(["{", options.bracketSpacing ? " " : "", concat$6(grouped), options.bracketSpacing ? " " : "", "}"])); ++ } else if (grouped.length >= 1) { ++ parts.push(group$2(concat$6(["{", indent$3(concat$6([options.bracketSpacing ? line$4 : softline$2, join$4(concat$6([",", line$4]), grouped)])), ifBreak$1(shouldPrintComma(options) ? "," : ""), options.bracketSpacing ? line$4 : softline$2, "}"]))); ++ } ++ ++ parts.push(" from "); ++ } else if (n.importKind && n.importKind === "type" || // import {} from 'x' ++ /{\s*}/.test(options.originalText.slice(options.locStart(n), options.locStart(n.source)))) { ++ parts.push("{} from "); ++ } ++ ++ parts.push(path.call(print, "source"), semi); ++ return concat$6(parts); ++ } ++ ++ case "Import": ++ return "import"; ++ ++ case "TSModuleBlock": ++ case "BlockStatement": ++ { ++ const naked = path.call(bodyPath => { ++ return printStatementSequence(bodyPath, options, print); ++ }, "body"); ++ const hasContent = n.body.find(node => node.type !== "EmptyStatement"); ++ const hasDirectives = n.directives && n.directives.length > 0; ++ const parent = path.getParentNode(); ++ const parentParent = path.getParentNode(1); ++ ++ if (!hasContent && !hasDirectives && !hasDanglingComments$1(n) && (parent.type === "ArrowFunctionExpression" || parent.type === "FunctionExpression" || parent.type === "FunctionDeclaration" || parent.type === "ObjectMethod" || parent.type === "ClassMethod" || parent.type === "ClassPrivateMethod" || parent.type === "ForStatement" || parent.type === "WhileStatement" || parent.type === "DoWhileStatement" || parent.type === "DoExpression" || parent.type === "CatchClause" && !parentParent.finalizer || parent.type === "TSModuleDeclaration")) { ++ return "{}"; ++ } ++ ++ parts.push("{"); // Babel 6 ++ ++ if (hasDirectives) { ++ path.each(childPath => { ++ parts.push(indent$3(concat$6([hardline$4, print(childPath), semi]))); ++ ++ if (isNextLineEmpty$2(options.originalText, childPath.getValue(), options.locEnd)) { ++ parts.push(hardline$4); ++ } ++ }, "directives"); ++ } ++ ++ if (hasContent) { ++ parts.push(indent$3(concat$6([hardline$4, naked]))); ++ } ++ ++ parts.push(comments.printDanglingComments(path, options)); ++ parts.push(hardline$4, "}"); ++ return concat$6(parts); ++ } ++ ++ case "ReturnStatement": ++ return concat$6(["return", printReturnAndThrowArgument(path, options, print)]); ++ ++ case "NewExpression": ++ case "OptionalCallExpression": ++ case "CallExpression": ++ { ++ const isNew = n.type === "NewExpression"; ++ const optional = printOptionalToken(path); ++ ++ if ( // We want to keep CommonJS- and AMD-style require calls, and AMD-style ++ // define calls, as a unit. ++ // e.g. `define(["some/lib", (lib) => {` ++ !isNew && n.callee.type === "Identifier" && (n.callee.name === "require" || n.callee.name === "define") || // Template literals as single arguments ++ n.arguments.length === 1 && isTemplateOnItsOwnLine$1(n.arguments[0], options.originalText, options) || // Keep test declarations on a single line ++ // e.g. `it('long name', () => {` ++ !isNew && isTestCall$1(n, path.getParentNode())) { ++ return concat$6([isNew ? "new " : "", path.call(print, "callee"), optional, printFunctionTypeParameters(path, options, print), concat$6(["(", join$4(", ", path.map(print, "arguments")), ")"])]); ++ } // Inline Flow annotation comments following Identifiers in Call nodes need to ++ // stay with the Identifier. For example: ++ // ++ // foo /*:: */(bar); ++ // ++ // Here, we ensure that such comments stay between the Identifier and the Callee. ++ ++ ++ const isIdentifierWithFlowAnnotation = n.callee.type === "Identifier" && hasFlowAnnotationComment$1(n.callee.trailingComments); ++ ++ if (isIdentifierWithFlowAnnotation) { ++ n.callee.trailingComments[0].printed = true; ++ } // We detect calls on member lookups and possibly print them in a ++ // special chain format. See `printMemberChain` for more info. ++ ++ ++ if (!isNew && isMemberish$1(n.callee) && !path.call(path => needsParens_1(path, options), "callee")) { ++ return printMemberChain(path, options, print); ++ } ++ ++ const contents = concat$6([isNew ? "new " : "", path.call(print, "callee"), optional, isIdentifierWithFlowAnnotation ? `/*:: ${n.callee.trailingComments[0].value.slice(2).trim()} */` : "", printFunctionTypeParameters(path, options, print), printArgumentsList(path, options, print)]); // We group here when the callee is itself a call expression. ++ // See `isLongCurriedCallExpression` for more info. ++ ++ if (isCallOrOptionalCallExpression$1(n.callee)) { ++ return group$2(contents); ++ } ++ ++ return contents; ++ } ++ ++ case "TSInterfaceDeclaration": ++ if (n.declare) { ++ parts.push("declare "); ++ } ++ ++ parts.push(n.abstract ? "abstract " : "", printTypeScriptModifiers(path, options, print), "interface ", path.call(print, "id"), n.typeParameters ? path.call(print, "typeParameters") : "", " "); ++ ++ if (n.extends && n.extends.length) { ++ parts.push(group$2(indent$3(concat$6([softline$2, "extends ", (n.extends.length === 1 ? identity$2 : indent$3)(join$4(concat$6([",", line$4]), path.map(print, "extends"))), " "])))); ++ } ++ ++ parts.push(path.call(print, "body")); ++ return concat$6(parts); ++ ++ case "ObjectTypeInternalSlot": ++ return concat$6([n.static ? "static " : "", "[[", path.call(print, "id"), "]]", printOptionalToken(path), n.method ? "" : ": ", path.call(print, "value")]); ++ ++ case "ObjectExpression": ++ case "ObjectPattern": ++ case "ObjectTypeAnnotation": ++ case "TSInterfaceBody": ++ case "TSTypeLiteral": ++ { ++ let propertiesField; ++ ++ if (n.type === "TSTypeLiteral") { ++ propertiesField = "members"; ++ } else if (n.type === "TSInterfaceBody") { ++ propertiesField = "body"; ++ } else { ++ propertiesField = "properties"; ++ } ++ ++ const isTypeAnnotation = n.type === "ObjectTypeAnnotation"; ++ const fields = []; ++ ++ if (isTypeAnnotation) { ++ fields.push("indexers", "callProperties", "internalSlots"); ++ } ++ ++ fields.push(propertiesField); ++ const firstProperty = fields.map(field => n[field][0]).sort((a, b) => options.locStart(a) - options.locStart(b))[0]; ++ const parent = path.getParentNode(0); ++ const isFlowInterfaceLikeBody = isTypeAnnotation && parent && (parent.type === "InterfaceDeclaration" || parent.type === "DeclareInterface" || parent.type === "DeclareClass") && path.getName() === "body"; ++ const shouldBreak = n.type === "TSInterfaceBody" || isFlowInterfaceLikeBody || n.type === "ObjectPattern" && parent.type !== "FunctionDeclaration" && parent.type !== "FunctionExpression" && parent.type !== "ArrowFunctionExpression" && parent.type !== "ObjectMethod" && parent.type !== "ClassMethod" && parent.type !== "ClassPrivateMethod" && parent.type !== "AssignmentPattern" && parent.type !== "CatchClause" && n.properties.some(property => property.value && (property.value.type === "ObjectPattern" || property.value.type === "ArrayPattern")) || n.type !== "ObjectPattern" && firstProperty && hasNewlineInRange$3(options.originalText, options.locStart(n), options.locStart(firstProperty)); ++ const separator = isFlowInterfaceLikeBody ? ";" : n.type === "TSInterfaceBody" || n.type === "TSTypeLiteral" ? ifBreak$1(semi, ";") : ","; ++ const leftBrace = n.exact ? "{|" : "{"; ++ const rightBrace = n.exact ? "|}" : "}"; // Unfortunately, things are grouped together in the ast can be ++ // interleaved in the source code. So we need to reorder them before ++ // printing them. ++ ++ const propsAndLoc = []; ++ fields.forEach(field => { ++ path.each(childPath => { ++ const node = childPath.getValue(); ++ propsAndLoc.push({ ++ node, ++ printed: print(childPath), ++ loc: options.locStart(node) ++ }); ++ }, field); ++ }); ++ let separatorParts = []; ++ const props = propsAndLoc.sort((a, b) => a.loc - b.loc).map(prop => { ++ const result = concat$6(separatorParts.concat(group$2(prop.printed))); ++ separatorParts = [separator, line$4]; ++ ++ if ((prop.node.type === "TSPropertySignature" || prop.node.type === "TSMethodSignature" || prop.node.type === "TSConstructSignatureDeclaration") && hasNodeIgnoreComment$2(prop.node)) { ++ separatorParts.shift(); ++ } ++ ++ if (isNextLineEmpty$2(options.originalText, prop.node, options.locEnd)) { ++ separatorParts.push(hardline$4); ++ } ++ ++ return result; ++ }); ++ ++ if (n.inexact) { ++ props.push(concat$6(separatorParts.concat(group$2("...")))); ++ } ++ ++ const lastElem = getLast$2(n[propertiesField]); ++ const canHaveTrailingSeparator = !(lastElem && (lastElem.type === "RestProperty" || lastElem.type === "RestElement" || hasNodeIgnoreComment$2(lastElem) || n.inexact)); ++ let content; ++ ++ if (props.length === 0) { ++ if (!hasDanglingComments$1(n)) { ++ return concat$6([leftBrace, rightBrace, printTypeAnnotation(path, options, print)]); ++ } ++ ++ content = group$2(concat$6([leftBrace, comments.printDanglingComments(path, options), softline$2, rightBrace, printOptionalToken(path), printTypeAnnotation(path, options, print)])); ++ } else { ++ content = concat$6([leftBrace, indent$3(concat$6([options.bracketSpacing ? line$4 : softline$2, concat$6(props)])), ifBreak$1(canHaveTrailingSeparator && (separator !== "," || shouldPrintComma(options)) ? separator : ""), concat$6([options.bracketSpacing ? line$4 : softline$2, rightBrace]), printOptionalToken(path), printTypeAnnotation(path, options, print)]); ++ } // If we inline the object as first argument of the parent, we don't want ++ // to create another group so that the object breaks before the return ++ // type ++ ++ ++ if (path.match(node => node.type === "ObjectPattern" && !node.decorators, (node, name, number) => shouldHugArguments(node) && (name === "params" || name === "parameters") && number === 0) || path.match(shouldHugType, (node, name) => name === "typeAnnotation", (node, name) => name === "typeAnnotation", (node, name, number) => shouldHugArguments(node) && (name === "params" || name === "parameters") && number === 0)) { ++ return content; ++ } ++ ++ return group$2(content, { ++ shouldBreak ++ }); ++ } ++ // Babel 6 ++ ++ case "ObjectProperty": // Non-standard AST node type. ++ ++ case "Property": ++ if (n.method || n.kind === "get" || n.kind === "set") { ++ return printMethod(path, options, print); ++ } ++ ++ if (n.shorthand) { ++ parts.push(path.call(print, "value")); ++ } else { ++ parts.push(printAssignment(n.key, printPropertyKey(path, options, print), ":", n.value, path.call(print, "value"), options)); ++ } ++ ++ return concat$6(parts); ++ // Babel 6 ++ ++ case "ClassMethod": ++ case "ClassPrivateMethod": ++ case "MethodDefinition": ++ case "TSAbstractMethodDefinition": ++ case "TSDeclareMethod": ++ if (n.decorators && n.decorators.length !== 0) { ++ parts.push(printDecorators(path, options, print)); ++ } ++ ++ if (n.accessibility) { ++ parts.push(n.accessibility + " "); ++ } ++ ++ if (n.static) { ++ parts.push("static "); ++ } ++ ++ if (n.type === "TSAbstractMethodDefinition" || n.abstract) { ++ parts.push("abstract "); ++ } ++ ++ parts.push(printMethod(path, options, print)); ++ return concat$6(parts); ++ ++ case "ObjectMethod": ++ return printMethod(path, options, print); ++ ++ case "Decorator": ++ return concat$6(["@", path.call(print, "expression"), path.call(print, "callee")]); ++ ++ case "ArrayExpression": ++ case "ArrayPattern": ++ if (n.elements.length === 0) { ++ if (!hasDanglingComments$1(n)) { ++ parts.push("[]"); ++ } else { ++ parts.push(group$2(concat$6(["[", comments.printDanglingComments(path, options), softline$2, "]"]))); ++ } ++ } else { ++ const lastElem = getLast$2(n.elements); ++ const canHaveTrailingComma = !(lastElem && lastElem.type === "RestElement"); // JavaScript allows you to have empty elements in an array which ++ // changes its length based on the number of commas. The algorithm ++ // is that if the last argument is null, we need to force insert ++ // a comma to ensure JavaScript recognizes it. ++ // [,].length === 1 ++ // [1,].length === 1 ++ // [1,,].length === 2 ++ // ++ // Note that getLast returns null if the array is empty, but ++ // we already check for an empty array just above so we are safe ++ ++ const needsForcedTrailingComma = canHaveTrailingComma && lastElem === null; ++ const shouldBreak = n.elements.length > 1 && n.elements.every((element, i, elements) => { ++ const elementType = element && element.type; ++ ++ if (elementType !== "ArrayExpression" && elementType !== "ObjectExpression") { ++ return false; ++ } ++ ++ const nextElement = elements[i + 1]; ++ ++ if (nextElement && elementType !== nextElement.type) { ++ return false; ++ } ++ ++ const itemsKey = elementType === "ArrayExpression" ? "elements" : "properties"; ++ return element[itemsKey] && element[itemsKey].length > 1; ++ }); ++ parts.push(group$2(concat$6(["[", indent$3(concat$6([softline$2, printArrayItems(path, options, "elements", print)])), needsForcedTrailingComma ? "," : "", ifBreak$1(canHaveTrailingComma && !needsForcedTrailingComma && shouldPrintComma(options) ? "," : ""), comments.printDanglingComments(path, options, ++ /* sameIndent */ ++ true), softline$2, "]"]), { ++ shouldBreak ++ })); ++ } ++ ++ parts.push(printOptionalToken(path), printTypeAnnotation(path, options, print)); ++ return concat$6(parts); ++ ++ case "SequenceExpression": ++ { ++ const parent = path.getParentNode(0); ++ ++ if (parent.type === "ExpressionStatement" || parent.type === "ForStatement") { ++ // For ExpressionStatements and for-loop heads, which are among ++ // the few places a SequenceExpression appears unparenthesized, we want ++ // to indent expressions after the first. ++ const parts = []; ++ path.each(p => { ++ if (p.getName() === 0) { ++ parts.push(print(p)); ++ } else { ++ parts.push(",", indent$3(concat$6([line$4, print(p)]))); ++ } ++ }, "expressions"); ++ return group$2(concat$6(parts)); ++ } ++ ++ return group$2(concat$6([join$4(concat$6([",", line$4]), path.map(print, "expressions"))])); ++ } ++ ++ case "ThisExpression": ++ return "this"; ++ ++ case "Super": ++ return "super"; ++ ++ case "NullLiteral": ++ // Babel 6 Literal split ++ return "null"; ++ ++ case "RegExpLiteral": ++ // Babel 6 Literal split ++ return printRegex(n); ++ ++ case "NumericLiteral": ++ // Babel 6 Literal split ++ return printNumber$1(n.extra.raw); ++ ++ case "BigIntLiteral": ++ // babel: n.extra.raw, typescript: n.raw, flow: n.bigint ++ return (n.bigint || (n.extra ? n.extra.raw : n.raw)).toLowerCase(); ++ ++ case "BooleanLiteral": // Babel 6 Literal split ++ ++ case "StringLiteral": // Babel 6 Literal split ++ ++ case "Literal": ++ { ++ if (n.regex) { ++ return printRegex(n.regex); ++ } ++ ++ if (typeof n.value === "number") { ++ return printNumber$1(n.raw); ++ } ++ ++ if (typeof n.value !== "string") { ++ return "" + n.value; ++ } // TypeScript workaround for https://github.com/JamesHenry/typescript-estree/issues/2 ++ // See corresponding workaround in needs-parens.js ++ ++ ++ const grandParent = path.getParentNode(1); ++ const isTypeScriptDirective = options.parser === "typescript" && typeof n.value === "string" && grandParent && (grandParent.type === "Program" || grandParent.type === "BlockStatement"); ++ return nodeStr(n, options, isTypeScriptDirective); ++ } ++ ++ case "Directive": ++ return path.call(print, "value"); ++ // Babel 6 ++ ++ case "DirectiveLiteral": ++ return nodeStr(n, options); ++ ++ case "UnaryExpression": ++ parts.push(n.operator); ++ ++ if (/[a-z]$/.test(n.operator)) { ++ parts.push(" "); ++ } ++ ++ if (n.argument.comments && n.argument.comments.length > 0) { ++ parts.push(group$2(concat$6(["(", indent$3(concat$6([softline$2, path.call(print, "argument")])), softline$2, ")"]))); ++ } else { ++ parts.push(path.call(print, "argument")); ++ } ++ ++ return concat$6(parts); ++ ++ case "UpdateExpression": ++ parts.push(path.call(print, "argument"), n.operator); ++ ++ if (n.prefix) { ++ parts.reverse(); ++ } ++ ++ return concat$6(parts); ++ ++ case "ConditionalExpression": ++ return printTernaryOperator(path, options, print, { ++ beforeParts: () => [path.call(print, "test")], ++ afterParts: breakClosingParen => [breakClosingParen ? softline$2 : ""], ++ shouldCheckJsx: true, ++ conditionalNodeType: "ConditionalExpression", ++ consequentNodePropertyName: "consequent", ++ alternateNodePropertyName: "alternate", ++ testNodePropertyNames: ["test"] ++ }); ++ ++ case "VariableDeclaration": ++ { ++ const printed = path.map(childPath => { ++ return print(childPath); ++ }, "declarations"); // We generally want to terminate all variable declarations with a ++ // semicolon, except when they in the () part of for loops. ++ ++ const parentNode = path.getParentNode(); ++ const isParentForLoop = parentNode.type === "ForStatement" || parentNode.type === "ForInStatement" || parentNode.type === "ForOfStatement" || parentNode.type === "ForAwaitStatement"; ++ const hasValue = n.declarations.some(decl => decl.init); ++ let firstVariable; ++ ++ if (printed.length === 1 && !n.declarations[0].comments) { ++ firstVariable = printed[0]; ++ } else if (printed.length > 0) { ++ // Indent first var to comply with eslint one-var rule ++ firstVariable = indent$3(printed[0]); ++ } ++ ++ parts = [n.declare ? "declare " : "", n.kind, firstVariable ? concat$6([" ", firstVariable]) : "", indent$3(concat$6(printed.slice(1).map(p => concat$6([",", hasValue && !isParentForLoop ? hardline$4 : line$4, p]))))]; ++ ++ if (!(isParentForLoop && parentNode.body !== n)) { ++ parts.push(semi); ++ } ++ ++ return group$2(concat$6(parts)); ++ } ++ ++ case "TSTypeAliasDeclaration": ++ { ++ if (n.declare) { ++ parts.push("declare "); ++ } ++ ++ const printed = printAssignmentRight(n.id, n.typeAnnotation, n.typeAnnotation && path.call(print, "typeAnnotation"), options); ++ parts.push("type ", path.call(print, "id"), path.call(print, "typeParameters"), " =", printed, semi); ++ return group$2(concat$6(parts)); ++ } ++ ++ case "VariableDeclarator": ++ return printAssignment(n.id, path.call(print, "id"), " =", n.init, n.init && path.call(print, "init"), options); ++ ++ case "WithStatement": ++ return group$2(concat$6(["with (", path.call(print, "object"), ")", adjustClause(n.body, path.call(print, "body"))])); ++ ++ case "IfStatement": ++ { ++ const con = adjustClause(n.consequent, path.call(print, "consequent")); ++ const opening = group$2(concat$6(["if (", group$2(concat$6([indent$3(concat$6([softline$2, path.call(print, "test")])), softline$2])), ")", con])); ++ parts.push(opening); ++ ++ if (n.alternate) { ++ const commentOnOwnLine = hasTrailingComment$1(n.consequent) && n.consequent.comments.some(comment => comment.trailing && !comments$1.isBlockComment(comment)) || needsHardlineAfterDanglingComment$1(n); ++ const elseOnSameLine = n.consequent.type === "BlockStatement" && !commentOnOwnLine; ++ parts.push(elseOnSameLine ? " " : hardline$4); ++ ++ if (hasDanglingComments$1(n)) { ++ parts.push(comments.printDanglingComments(path, options, true), commentOnOwnLine ? hardline$4 : " "); ++ } ++ ++ parts.push("else", group$2(adjustClause(n.alternate, path.call(print, "alternate"), n.alternate.type === "IfStatement"))); ++ } ++ ++ return concat$6(parts); ++ } ++ ++ case "ForStatement": ++ { ++ const body = adjustClause(n.body, path.call(print, "body")); // We want to keep dangling comments above the loop to stay consistent. ++ // Any comment positioned between the for statement and the parentheses ++ // is going to be printed before the statement. ++ ++ const dangling = comments.printDanglingComments(path, options, ++ /* sameLine */ ++ true); ++ const printedComments = dangling ? concat$6([dangling, softline$2]) : ""; ++ ++ if (!n.init && !n.test && !n.update) { ++ return concat$6([printedComments, group$2(concat$6(["for (;;)", body]))]); ++ } ++ ++ return concat$6([printedComments, group$2(concat$6(["for (", group$2(concat$6([indent$3(concat$6([softline$2, path.call(print, "init"), ";", line$4, path.call(print, "test"), ";", line$4, path.call(print, "update")])), softline$2])), ")", body]))]); ++ } ++ ++ case "WhileStatement": ++ return group$2(concat$6(["while (", group$2(concat$6([indent$3(concat$6([softline$2, path.call(print, "test")])), softline$2])), ")", adjustClause(n.body, path.call(print, "body"))])); ++ ++ case "ForInStatement": ++ // Note: esprima can't actually parse "for each (". ++ return group$2(concat$6([n.each ? "for each (" : "for (", path.call(print, "left"), " in ", path.call(print, "right"), ")", adjustClause(n.body, path.call(print, "body"))])); ++ ++ case "ForOfStatement": ++ case "ForAwaitStatement": ++ { ++ // Babel 7 removed ForAwaitStatement in favor of ForOfStatement ++ // with `"await": true`: ++ // https://github.com/estree/estree/pull/138 ++ const isAwait = n.type === "ForAwaitStatement" || n.await; ++ return group$2(concat$6(["for", isAwait ? " await" : "", " (", path.call(print, "left"), " of ", path.call(print, "right"), ")", adjustClause(n.body, path.call(print, "body"))])); ++ } ++ ++ case "DoWhileStatement": ++ { ++ const clause = adjustClause(n.body, path.call(print, "body")); ++ const doBody = group$2(concat$6(["do", clause])); ++ parts = [doBody]; ++ ++ if (n.body.type === "BlockStatement") { ++ parts.push(" "); ++ } else { ++ parts.push(hardline$4); ++ } ++ ++ parts.push("while ("); ++ parts.push(group$2(concat$6([indent$3(concat$6([softline$2, path.call(print, "test")])), softline$2])), ")", semi); ++ return concat$6(parts); ++ } ++ ++ case "DoExpression": ++ return concat$6(["do ", path.call(print, "body")]); ++ ++ case "BreakStatement": ++ parts.push("break"); ++ ++ if (n.label) { ++ parts.push(" ", path.call(print, "label")); ++ } ++ ++ parts.push(semi); ++ return concat$6(parts); ++ ++ case "ContinueStatement": ++ parts.push("continue"); ++ ++ if (n.label) { ++ parts.push(" ", path.call(print, "label")); ++ } ++ ++ parts.push(semi); ++ return concat$6(parts); ++ ++ case "LabeledStatement": ++ if (n.body.type === "EmptyStatement") { ++ return concat$6([path.call(print, "label"), ":;"]); ++ } ++ ++ return concat$6([path.call(print, "label"), ": ", path.call(print, "body")]); ++ ++ case "TryStatement": ++ return concat$6(["try ", path.call(print, "block"), n.handler ? concat$6([" ", path.call(print, "handler")]) : "", n.finalizer ? concat$6([" finally ", path.call(print, "finalizer")]) : ""]); ++ ++ case "CatchClause": ++ if (n.param) { ++ const hasComments = n.param.comments && n.param.comments.some(comment => !comments$1.isBlockComment(comment) || comment.leading && hasNewline$4(options.originalText, options.locEnd(comment)) || comment.trailing && hasNewline$4(options.originalText, options.locStart(comment), { ++ backwards: true ++ })); ++ const param = path.call(print, "param"); ++ return concat$6(["catch ", hasComments ? concat$6(["(", indent$3(concat$6([softline$2, param])), softline$2, ") "]) : concat$6(["(", param, ") "]), path.call(print, "body")]); ++ } ++ ++ return concat$6(["catch ", path.call(print, "body")]); ++ ++ case "ThrowStatement": ++ return concat$6(["throw", printReturnAndThrowArgument(path, options, print)]); ++ // Note: ignoring n.lexical because it has no printing consequences. ++ ++ case "SwitchStatement": ++ return concat$6([group$2(concat$6(["switch (", indent$3(concat$6([softline$2, path.call(print, "discriminant")])), softline$2, ")"])), " {", n.cases.length > 0 ? indent$3(concat$6([hardline$4, join$4(hardline$4, path.map(casePath => { ++ const caseNode = casePath.getValue(); ++ return concat$6([casePath.call(print), n.cases.indexOf(caseNode) !== n.cases.length - 1 && isNextLineEmpty$2(options.originalText, caseNode, options.locEnd) ? hardline$4 : ""]); ++ }, "cases"))])) : "", hardline$4, "}"]); ++ ++ case "SwitchCase": ++ { ++ if (n.test) { ++ parts.push("case ", path.call(print, "test"), ":"); ++ } else { ++ parts.push("default:"); ++ } ++ ++ const consequent = n.consequent.filter(node => node.type !== "EmptyStatement"); ++ ++ if (consequent.length > 0) { ++ const cons = path.call(consequentPath => { ++ return printStatementSequence(consequentPath, options, print); ++ }, "consequent"); ++ parts.push(consequent.length === 1 && consequent[0].type === "BlockStatement" ? concat$6([" ", cons]) : indent$3(concat$6([hardline$4, cons]))); ++ } ++ ++ return concat$6(parts); ++ } ++ // JSX extensions below. ++ ++ case "DebuggerStatement": ++ return concat$6(["debugger", semi]); ++ ++ case "JSXAttribute": ++ parts.push(path.call(print, "name")); ++ ++ if (n.value) { ++ let res; ++ ++ if (isStringLiteral$1(n.value)) { ++ const raw = rawText$1(n.value); // Unescape all quotes so we get an accurate preferred quote ++ ++ let final = raw.replace(/'/g, "'").replace(/"/g, '"'); ++ const quote = getPreferredQuote$1(final, options.jsxSingleQuote ? "'" : '"'); ++ const escape = quote === "'" ? "'" : """; ++ final = final.slice(1, -1).replace(new RegExp(quote, "g"), escape); ++ res = concat$6([quote, final, quote]); ++ } else { ++ res = path.call(print, "value"); ++ } ++ ++ parts.push("=", res); ++ } ++ ++ return concat$6(parts); ++ ++ case "JSXIdentifier": ++ return "" + n.name; ++ ++ case "JSXNamespacedName": ++ return join$4(":", [path.call(print, "namespace"), path.call(print, "name")]); ++ ++ case "JSXMemberExpression": ++ return join$4(".", [path.call(print, "object"), path.call(print, "property")]); ++ ++ case "TSQualifiedName": ++ return join$4(".", [path.call(print, "left"), path.call(print, "right")]); ++ ++ case "JSXSpreadAttribute": ++ case "JSXSpreadChild": ++ { ++ return concat$6(["{", path.call(p => { ++ const printed = concat$6(["...", print(p)]); ++ const n = p.getValue(); ++ ++ if (!n.comments || !n.comments.length) { ++ return printed; ++ } ++ ++ return concat$6([indent$3(concat$6([softline$2, comments.printComments(p, () => printed, options)])), softline$2]); ++ }, n.type === "JSXSpreadAttribute" ? "argument" : "expression"), "}"]); ++ } ++ ++ case "JSXExpressionContainer": ++ { ++ const parent = path.getParentNode(0); ++ const preventInline = parent.type === "JSXAttribute" && n.expression.comments && n.expression.comments.length > 0; ++ const shouldInline = !preventInline && (n.expression.type === "ArrayExpression" || n.expression.type === "ObjectExpression" || n.expression.type === "ArrowFunctionExpression" || n.expression.type === "CallExpression" || n.expression.type === "OptionalCallExpression" || n.expression.type === "FunctionExpression" || n.expression.type === "JSXEmptyExpression" || n.expression.type === "TemplateLiteral" || n.expression.type === "TaggedTemplateExpression" || n.expression.type === "DoExpression" || isJSXNode$1(parent) && (n.expression.type === "ConditionalExpression" || isBinaryish$1(n.expression))); ++ ++ if (shouldInline) { ++ return group$2(concat$6(["{", path.call(print, "expression"), lineSuffixBoundary$1, "}"])); ++ } ++ ++ return group$2(concat$6(["{", indent$3(concat$6([softline$2, path.call(print, "expression")])), softline$2, lineSuffixBoundary$1, "}"])); ++ } ++ ++ case "JSXFragment": ++ case "JSXElement": ++ { ++ const elem = comments.printComments(path, () => printJSXElement(path, options, print), options); ++ return maybeWrapJSXElementInParens(path, elem, options); ++ } ++ ++ case "JSXOpeningElement": ++ { ++ const n = path.getValue(); ++ const nameHasComments = n.name && n.name.comments && n.name.comments.length > 0 || n.typeParameters && n.typeParameters.comments && n.typeParameters.comments.length > 0; // Don't break self-closing elements with no attributes and no comments ++ ++ if (n.selfClosing && !n.attributes.length && !nameHasComments) { ++ return concat$6(["<", path.call(print, "name"), path.call(print, "typeParameters"), " />"]); ++ } // don't break up opening elements with a single long text attribute ++ ++ ++ if (n.attributes && n.attributes.length === 1 && n.attributes[0].value && isStringLiteral$1(n.attributes[0].value) && !n.attributes[0].value.value.includes("\n") && // We should break for the following cases: ++ //
++ //
++ !nameHasComments && (!n.attributes[0].comments || !n.attributes[0].comments.length)) { ++ return group$2(concat$6(["<", path.call(print, "name"), path.call(print, "typeParameters"), " ", concat$6(path.map(print, "attributes")), n.selfClosing ? " />" : ">"])); ++ } ++ ++ const lastAttrHasTrailingComments = n.attributes.length && hasTrailingComment$1(getLast$2(n.attributes)); ++ const bracketSameLine = // Simple tags (no attributes and no comment in tag name) should be ++ // kept unbroken regardless of `jsxBracketSameLine` ++ !n.attributes.length && !nameHasComments || options.jsxBracketSameLine && ( // We should print the bracket in a new line for the following cases: ++ //
++ //
++ !nameHasComments || n.attributes.length) && !lastAttrHasTrailingComments; // We should print the opening element expanded if any prop value is a ++ // string literal with newlines ++ ++ const shouldBreak = n.attributes && n.attributes.some(attr => attr.value && isStringLiteral$1(attr.value) && attr.value.value.includes("\n")); ++ return group$2(concat$6(["<", path.call(print, "name"), path.call(print, "typeParameters"), concat$6([indent$3(concat$6(path.map(attr => concat$6([line$4, print(attr)]), "attributes"))), n.selfClosing ? line$4 : bracketSameLine ? ">" : softline$2]), n.selfClosing ? "/>" : bracketSameLine ? "" : ">"]), { ++ shouldBreak ++ }); ++ } ++ ++ case "JSXClosingElement": ++ return concat$6([""]); ++ ++ case "JSXOpeningFragment": ++ case "JSXClosingFragment": ++ { ++ const hasComment = n.comments && n.comments.length; ++ const hasOwnLineComment = hasComment && !n.comments.every(comments$1.isBlockComment); ++ const isOpeningFragment = n.type === "JSXOpeningFragment"; ++ return concat$6([isOpeningFragment ? "<" : ""]); ++ } ++ ++ case "JSXText": ++ /* istanbul ignore next */ ++ throw new Error("JSXTest should be handled by JSXElement"); ++ ++ case "JSXEmptyExpression": ++ { ++ const requiresHardline = n.comments && !n.comments.every(comments$1.isBlockComment); ++ return concat$6([comments.printDanglingComments(path, options, ++ /* sameIndent */ ++ !requiresHardline), requiresHardline ? hardline$4 : ""]); ++ } ++ ++ case "ClassBody": ++ if (!n.comments && n.body.length === 0) { ++ return "{}"; ++ } ++ ++ return concat$6(["{", n.body.length > 0 ? indent$3(concat$6([hardline$4, path.call(bodyPath => { ++ return printStatementSequence(bodyPath, options, print); ++ }, "body")])) : comments.printDanglingComments(path, options), hardline$4, "}"]); ++ ++ case "ClassProperty": ++ case "TSAbstractClassProperty": ++ case "ClassPrivateProperty": ++ { ++ if (n.decorators && n.decorators.length !== 0) { ++ parts.push(printDecorators(path, options, print)); ++ } ++ ++ if (n.accessibility) { ++ parts.push(n.accessibility + " "); ++ } ++ ++ if (n.declare) { ++ parts.push("declare "); ++ } ++ ++ if (n.static) { ++ parts.push("static "); ++ } ++ ++ if (n.type === "TSAbstractClassProperty" || n.abstract) { ++ parts.push("abstract "); ++ } ++ ++ if (n.readonly) { ++ parts.push("readonly "); ++ } ++ ++ const variance = getFlowVariance$1(n); ++ ++ if (variance) { ++ parts.push(variance); ++ } ++ ++ parts.push(printPropertyKey(path, options, print), printOptionalToken(path), printTypeAnnotation(path, options, print)); ++ ++ if (n.value) { ++ parts.push(" =", printAssignmentRight(n.key, n.value, path.call(print, "value"), options)); ++ } ++ ++ parts.push(semi); ++ return group$2(concat$6(parts)); ++ } ++ ++ case "ClassDeclaration": ++ case "ClassExpression": ++ if (n.declare) { ++ parts.push("declare "); ++ } ++ ++ parts.push(concat$6(printClass(path, options, print))); ++ return concat$6(parts); ++ ++ case "TSInterfaceHeritage": ++ case "TSExpressionWithTypeArguments": ++ // Babel AST ++ parts.push(path.call(print, "expression")); ++ ++ if (n.typeParameters) { ++ parts.push(path.call(print, "typeParameters")); ++ } ++ ++ return concat$6(parts); ++ ++ case "TemplateElement": ++ return join$4(literalline$2, n.value.raw.split(/\r?\n/g)); ++ ++ case "TemplateLiteral": ++ { ++ let expressions = path.map(print, "expressions"); ++ const parentNode = path.getParentNode(); ++ ++ if (isJestEachTemplateLiteral$1(n, parentNode)) { ++ const printed = printJestEachTemplateLiteral(n, expressions, options); ++ ++ if (printed) { ++ return printed; ++ } ++ } ++ ++ const isSimple = isSimpleTemplateLiteral$1(n); ++ ++ if (isSimple) { ++ expressions = expressions.map(doc => printDocToString$2(doc, Object.assign({}, options, { ++ printWidth: Infinity ++ })).formatted); ++ } ++ ++ parts.push(lineSuffixBoundary$1, "`"); ++ path.each(childPath => { ++ const i = childPath.getName(); ++ parts.push(print(childPath)); ++ ++ if (i < expressions.length) { ++ // For a template literal of the following form: ++ // `someQuery { ++ // ${call({ ++ // a, ++ // b, ++ // })} ++ // }` ++ // the expression is on its own line (there is a \n in the previous ++ // quasi literal), therefore we want to indent the JavaScript ++ // expression inside at the beginning of ${ instead of the beginning ++ // of the `. ++ const { ++ tabWidth ++ } = options; ++ const quasi = childPath.getValue(); ++ const indentSize = getIndentSize$2(quasi.value.raw, tabWidth); ++ let printed = expressions[i]; ++ ++ if (!isSimple) { ++ // Breaks at the template element boundaries (${ and }) are preferred to breaking ++ // in the middle of a MemberExpression ++ if (n.expressions[i].comments && n.expressions[i].comments.length || n.expressions[i].type === "MemberExpression" || n.expressions[i].type === "OptionalMemberExpression" || n.expressions[i].type === "ConditionalExpression" || n.expressions[i].type === "LogicalExpression" || n.expressions[i].type === "BinaryExpression" || n.expressions[i].type === "SequenceExpression" || n.expressions[i].type === "TSAsExpression") { ++ printed = concat$6([indent$3(concat$6([softline$2, printed])), softline$2]); ++ } ++ } ++ ++ const aligned = indentSize === 0 && quasi.value.raw.endsWith("\n") ? align$1(-Infinity, printed) : addAlignmentToDoc$2(printed, indentSize, tabWidth); ++ parts.push(group$2(concat$6(["${", aligned, lineSuffixBoundary$1, "}"]))); ++ } ++ }, "quasis"); ++ parts.push("`"); ++ return concat$6(parts); ++ } ++ // These types are unprintable because they serve as abstract ++ // supertypes for other (printable) types. ++ ++ case "TaggedTemplateExpression": ++ return concat$6([path.call(print, "tag"), path.call(print, "typeParameters"), path.call(print, "quasi")]); ++ ++ case "Node": ++ case "Printable": ++ case "SourceLocation": ++ case "Position": ++ case "Statement": ++ case "Function": ++ case "Pattern": ++ case "Expression": ++ case "Declaration": ++ case "Specifier": ++ case "NamedSpecifier": ++ case "Comment": ++ case "MemberTypeAnnotation": // Flow ++ ++ case "Type": ++ /* istanbul ignore next */ ++ throw new Error("unprintable type: " + JSON.stringify(n.type)); ++ // Type Annotations for Facebook Flow, typically stripped out or ++ // transformed away before printing. ++ ++ case "TypeAnnotation": ++ case "TSTypeAnnotation": ++ if (n.typeAnnotation) { ++ return path.call(print, "typeAnnotation"); ++ } ++ /* istanbul ignore next */ ++ ++ ++ return ""; ++ ++ case "TSTupleType": ++ case "TupleTypeAnnotation": ++ { ++ const typesField = n.type === "TSTupleType" ? "elementTypes" : "types"; ++ const hasRest = n[typesField].length > 0 && getLast$2(n[typesField]).type === "TSRestType"; ++ return group$2(concat$6(["[", indent$3(concat$6([softline$2, printArrayItems(path, options, typesField, print)])), ifBreak$1(shouldPrintComma(options, "all") && !hasRest ? "," : ""), comments.printDanglingComments(path, options, ++ /* sameIndent */ ++ true), softline$2, "]"])); ++ } ++ ++ case "ExistsTypeAnnotation": ++ return "*"; ++ ++ case "EmptyTypeAnnotation": ++ return "empty"; ++ ++ case "AnyTypeAnnotation": ++ return "any"; ++ ++ case "MixedTypeAnnotation": ++ return "mixed"; ++ ++ case "ArrayTypeAnnotation": ++ return concat$6([path.call(print, "elementType"), "[]"]); ++ ++ case "BooleanTypeAnnotation": ++ return "boolean"; ++ ++ case "BooleanLiteralTypeAnnotation": ++ return "" + n.value; ++ ++ case "DeclareClass": ++ return printFlowDeclaration(path, printClass(path, options, print)); ++ ++ case "TSDeclareFunction": ++ // For TypeScript the TSDeclareFunction node shares the AST ++ // structure with FunctionDeclaration ++ return concat$6([n.declare ? "declare " : "", printFunctionDeclaration(path, print, options), semi]); ++ ++ case "DeclareFunction": ++ return printFlowDeclaration(path, ["function ", path.call(print, "id"), n.predicate ? " " : "", path.call(print, "predicate"), semi]); ++ ++ case "DeclareModule": ++ return printFlowDeclaration(path, ["module ", path.call(print, "id"), " ", path.call(print, "body")]); ++ ++ case "DeclareModuleExports": ++ return printFlowDeclaration(path, ["module.exports", ": ", path.call(print, "typeAnnotation"), semi]); ++ ++ case "DeclareVariable": ++ return printFlowDeclaration(path, ["var ", path.call(print, "id"), semi]); ++ ++ case "DeclareExportAllDeclaration": ++ return concat$6(["declare export * from ", path.call(print, "source")]); ++ ++ case "DeclareExportDeclaration": ++ return concat$6(["declare ", printExportDeclaration(path, options, print)]); ++ ++ case "DeclareOpaqueType": ++ case "OpaqueType": ++ { ++ parts.push("opaque type ", path.call(print, "id"), path.call(print, "typeParameters")); ++ ++ if (n.supertype) { ++ parts.push(": ", path.call(print, "supertype")); ++ } ++ ++ if (n.impltype) { ++ parts.push(" = ", path.call(print, "impltype")); ++ } ++ ++ parts.push(semi); ++ ++ if (n.type === "DeclareOpaqueType") { ++ return printFlowDeclaration(path, parts); ++ } ++ ++ return concat$6(parts); ++ } ++ ++ case "EnumDeclaration": ++ return concat$6(["enum ", path.call(print, "id"), " ", path.call(print, "body")]); ++ ++ case "EnumBooleanBody": ++ case "EnumNumberBody": ++ case "EnumStringBody": ++ case "EnumSymbolBody": ++ { ++ if (n.type === "EnumSymbolBody" || n.explicitType) { ++ let type = null; ++ ++ switch (n.type) { ++ case "EnumBooleanBody": ++ type = "boolean"; ++ break; ++ ++ case "EnumNumberBody": ++ type = "number"; ++ break; ++ ++ case "EnumStringBody": ++ type = "string"; ++ break; ++ ++ case "EnumSymbolBody": ++ type = "symbol"; ++ break; ++ } ++ ++ parts.push("of ", type, " "); ++ } ++ ++ if (n.members.length === 0) { ++ parts.push(group$2(concat$6(["{", comments.printDanglingComments(path, options), softline$2, "}"]))); ++ } else { ++ parts.push(group$2(concat$6(["{", indent$3(concat$6([hardline$4, printArrayItems(path, options, "members", print), shouldPrintComma(options) ? "," : ""])), comments.printDanglingComments(path, options, ++ /* sameIndent */ ++ true), hardline$4, "}"]))); ++ } ++ ++ return concat$6(parts); ++ } ++ ++ case "EnumBooleanMember": ++ case "EnumNumberMember": ++ case "EnumStringMember": ++ return concat$6([path.call(print, "id"), " = ", typeof n.init === "object" ? path.call(print, "init") : String(n.init)]); ++ ++ case "EnumDefaultedMember": ++ return path.call(print, "id"); ++ ++ case "FunctionTypeAnnotation": ++ case "TSFunctionType": ++ { ++ // FunctionTypeAnnotation is ambiguous: ++ // declare function foo(a: B): void; OR ++ // var A: (a: B) => void; ++ const parent = path.getParentNode(0); ++ const parentParent = path.getParentNode(1); ++ const parentParentParent = path.getParentNode(2); ++ let isArrowFunctionTypeAnnotation = n.type === "TSFunctionType" || !((parent.type === "ObjectTypeProperty" || parent.type === "ObjectTypeInternalSlot") && !getFlowVariance$1(parent) && !parent.optional && options.locStart(parent) === options.locStart(n) || parent.type === "ObjectTypeCallProperty" || parentParentParent && parentParentParent.type === "DeclareFunction"); ++ let needsColon = isArrowFunctionTypeAnnotation && (parent.type === "TypeAnnotation" || parent.type === "TSTypeAnnotation"); // Sadly we can't put it inside of FastPath::needsColon because we are ++ // printing ":" as part of the expression and it would put parenthesis ++ // around :( ++ ++ const needsParens = needsColon && isArrowFunctionTypeAnnotation && (parent.type === "TypeAnnotation" || parent.type === "TSTypeAnnotation") && parentParent.type === "ArrowFunctionExpression"; ++ ++ if (isObjectTypePropertyAFunction$1(parent, options)) { ++ isArrowFunctionTypeAnnotation = true; ++ needsColon = true; ++ } ++ ++ if (needsParens) { ++ parts.push("("); ++ } ++ ++ parts.push(printFunctionParams(path, print, options, ++ /* expandArg */ ++ false, ++ /* printTypeParams */ ++ true)); // The returnType is not wrapped in a TypeAnnotation, so the colon ++ // needs to be added separately. ++ ++ if (n.returnType || n.predicate || n.typeAnnotation) { ++ parts.push(isArrowFunctionTypeAnnotation ? " => " : ": ", path.call(print, "returnType"), path.call(print, "predicate"), path.call(print, "typeAnnotation")); ++ } ++ ++ if (needsParens) { ++ parts.push(")"); ++ } ++ ++ return group$2(concat$6(parts)); ++ } ++ ++ case "TSRestType": ++ return concat$6(["...", path.call(print, "typeAnnotation")]); ++ ++ case "TSOptionalType": ++ return concat$6([path.call(print, "typeAnnotation"), "?"]); ++ ++ case "FunctionTypeParam": ++ return concat$6([path.call(print, "name"), printOptionalToken(path), n.name ? ": " : "", path.call(print, "typeAnnotation")]); ++ ++ case "GenericTypeAnnotation": ++ return concat$6([path.call(print, "id"), path.call(print, "typeParameters")]); ++ ++ case "DeclareInterface": ++ case "InterfaceDeclaration": ++ case "InterfaceTypeAnnotation": ++ { ++ if (n.type === "DeclareInterface" || n.declare) { ++ parts.push("declare "); ++ } ++ ++ parts.push("interface"); ++ ++ if (n.type === "DeclareInterface" || n.type === "InterfaceDeclaration") { ++ parts.push(" ", path.call(print, "id"), path.call(print, "typeParameters")); ++ } ++ ++ if (n.extends.length > 0) { ++ parts.push(group$2(indent$3(concat$6([line$4, "extends ", (n.extends.length === 1 ? identity$2 : indent$3)(join$4(concat$6([",", line$4]), path.map(print, "extends")))])))); ++ } ++ ++ parts.push(" ", path.call(print, "body")); ++ return group$2(concat$6(parts)); ++ } ++ ++ case "ClassImplements": ++ case "InterfaceExtends": ++ return concat$6([path.call(print, "id"), path.call(print, "typeParameters")]); ++ ++ case "TSClassImplements": ++ return concat$6([path.call(print, "expression"), path.call(print, "typeParameters")]); ++ ++ case "TSIntersectionType": ++ case "IntersectionTypeAnnotation": ++ { ++ const types = path.map(print, "types"); ++ const result = []; ++ let wasIndented = false; ++ ++ for (let i = 0; i < types.length; ++i) { ++ if (i === 0) { ++ result.push(types[i]); ++ } else if (isObjectType$1(n.types[i - 1]) && isObjectType$1(n.types[i])) { ++ // If both are objects, don't indent ++ result.push(concat$6([" & ", wasIndented ? indent$3(types[i]) : types[i]])); ++ } else if (!isObjectType$1(n.types[i - 1]) && !isObjectType$1(n.types[i])) { ++ // If no object is involved, go to the next line if it breaks ++ result.push(indent$3(concat$6([" &", line$4, types[i]]))); ++ } else { ++ // If you go from object to non-object or vis-versa, then inline it ++ if (i > 1) { ++ wasIndented = true; ++ } ++ ++ result.push(" & ", i > 1 ? indent$3(types[i]) : types[i]); ++ } ++ } ++ ++ return group$2(concat$6(result)); ++ } ++ ++ case "TSUnionType": ++ case "UnionTypeAnnotation": ++ { ++ // single-line variation ++ // A | B | C ++ // multi-line variation ++ // | A ++ // | B ++ // | C ++ const parent = path.getParentNode(); // If there's a leading comment, the parent is doing the indentation ++ ++ const shouldIndent = parent.type !== "TypeParameterInstantiation" && parent.type !== "TSTypeParameterInstantiation" && parent.type !== "GenericTypeAnnotation" && parent.type !== "TSTypeReference" && parent.type !== "TSTypeAssertion" && parent.type !== "TupleTypeAnnotation" && parent.type !== "TSTupleType" && !(parent.type === "FunctionTypeParam" && !parent.name) && !((parent.type === "TypeAlias" || parent.type === "VariableDeclarator" || parent.type === "TSTypeAliasDeclaration") && hasLeadingOwnLineComment$1(options.originalText, n, options)); // { ++ // a: string ++ // } | null | void ++ // should be inlined and not be printed in the multi-line variant ++ ++ const shouldHug = shouldHugType(n); // We want to align the children but without its comment, so it looks like ++ // | child1 ++ // // comment ++ // | child2 ++ ++ const printed = path.map(typePath => { ++ let printedType = typePath.call(print); ++ ++ if (!shouldHug) { ++ printedType = align$1(2, printedType); ++ } ++ ++ return comments.printComments(typePath, () => printedType, options); ++ }, "types"); ++ ++ if (shouldHug) { ++ return join$4(" | ", printed); ++ } ++ ++ const shouldAddStartLine = shouldIndent && !hasLeadingOwnLineComment$1(options.originalText, n, options); ++ const code = concat$6([ifBreak$1(concat$6([shouldAddStartLine ? line$4 : "", "| "])), join$4(concat$6([line$4, "| "]), printed)]); ++ ++ if (needsParens_1(path, options)) { ++ return group$2(concat$6([indent$3(code), softline$2])); ++ } ++ ++ if (parent.type === "TupleTypeAnnotation" && parent.types.length > 1 || parent.type === "TSTupleType" && parent.elementTypes.length > 1) { ++ return group$2(concat$6([indent$3(concat$6([ifBreak$1(concat$6(["(", softline$2])), code])), softline$2, ifBreak$1(")")])); ++ } ++ ++ return group$2(shouldIndent ? indent$3(code) : code); ++ } ++ ++ case "NullableTypeAnnotation": ++ return concat$6(["?", path.call(print, "typeAnnotation")]); ++ ++ case "TSNullKeyword": ++ case "NullLiteralTypeAnnotation": ++ return "null"; ++ ++ case "ThisTypeAnnotation": ++ return "this"; ++ ++ case "NumberTypeAnnotation": ++ return "number"; ++ ++ case "SymbolTypeAnnotation": ++ return "symbol"; ++ ++ case "ObjectTypeCallProperty": ++ if (n.static) { ++ parts.push("static "); ++ } ++ ++ parts.push(path.call(print, "value")); ++ return concat$6(parts); ++ ++ case "ObjectTypeIndexer": ++ { ++ const variance = getFlowVariance$1(n); ++ return concat$6([variance || "", "[", path.call(print, "id"), n.id ? ": " : "", path.call(print, "key"), "]: ", path.call(print, "value")]); ++ } ++ ++ case "ObjectTypeProperty": ++ { ++ const variance = getFlowVariance$1(n); ++ let modifier = ""; ++ ++ if (n.proto) { ++ modifier = "proto "; ++ } else if (n.static) { ++ modifier = "static "; ++ } ++ ++ return concat$6([modifier, isGetterOrSetter$1(n) ? n.kind + " " : "", variance || "", printPropertyKey(path, options, print), printOptionalToken(path), isFunctionNotation$1(n, options) ? "" : ": ", path.call(print, "value")]); ++ } ++ ++ case "QualifiedTypeIdentifier": ++ return concat$6([path.call(print, "qualification"), ".", path.call(print, "id")]); ++ ++ case "StringLiteralTypeAnnotation": ++ return nodeStr(n, options); ++ ++ case "NumberLiteralTypeAnnotation": ++ assert.strictEqual(typeof n.value, "number"); ++ ++ if (n.extra != null) { ++ return printNumber$1(n.extra.raw); ++ } ++ ++ return printNumber$1(n.raw); ++ ++ case "StringTypeAnnotation": ++ return "string"; ++ ++ case "DeclareTypeAlias": ++ case "TypeAlias": ++ { ++ if (n.type === "DeclareTypeAlias" || n.declare) { ++ parts.push("declare "); ++ } ++ ++ const printed = printAssignmentRight(n.id, n.right, path.call(print, "right"), options); ++ parts.push("type ", path.call(print, "id"), path.call(print, "typeParameters"), " =", printed, semi); ++ return group$2(concat$6(parts)); ++ } ++ ++ case "TypeCastExpression": ++ { ++ return concat$6(["(", path.call(print, "expression"), printTypeAnnotation(path, options, print), ")"]); ++ } ++ ++ case "TypeParameterDeclaration": ++ case "TypeParameterInstantiation": ++ { ++ const value = path.getValue(); ++ const commentStart = value.range ? options.originalText.slice(0, value.range[0]).lastIndexOf("/*") : -1; // As noted in the TypeCastExpression comments above, we're able to use a normal whitespace regex here ++ // because we know for sure that this is a type definition. ++ ++ const commentSyntax = commentStart >= 0 && options.originalText.slice(commentStart).match(/^\/\*\s*::/); ++ ++ if (commentSyntax) { ++ return concat$6(["/*:: ", printTypeParameters(path, options, print, "params"), " */"]); ++ } ++ ++ return printTypeParameters(path, options, print, "params"); ++ } ++ ++ case "TSTypeParameterDeclaration": ++ case "TSTypeParameterInstantiation": ++ return printTypeParameters(path, options, print, "params"); ++ ++ case "TSTypeParameter": ++ case "TypeParameter": ++ { ++ const parent = path.getParentNode(); ++ ++ if (parent.type === "TSMappedType") { ++ parts.push("[", path.call(print, "name")); ++ ++ if (n.constraint) { ++ parts.push(" in ", path.call(print, "constraint")); ++ } ++ ++ parts.push("]"); ++ return concat$6(parts); ++ } ++ ++ const variance = getFlowVariance$1(n); ++ ++ if (variance) { ++ parts.push(variance); ++ } ++ ++ parts.push(path.call(print, "name")); ++ ++ if (n.bound) { ++ parts.push(": "); ++ parts.push(path.call(print, "bound")); ++ } ++ ++ if (n.constraint) { ++ parts.push(" extends ", path.call(print, "constraint")); ++ } ++ ++ if (n.default) { ++ parts.push(" = ", path.call(print, "default")); ++ } // Keep comma if the file extension is .tsx and ++ // has one type parameter that isn't extend with any types. ++ // Because, otherwise formatted result will be invalid as tsx. ++ ++ ++ const grandParent = path.getNode(2); ++ ++ if (parent.params && parent.params.length === 1 && isTSXFile$1(options) && !n.constraint && grandParent.type === "ArrowFunctionExpression") { ++ parts.push(","); ++ } ++ ++ return concat$6(parts); ++ } ++ ++ case "TypeofTypeAnnotation": ++ return concat$6(["typeof ", path.call(print, "argument")]); ++ ++ case "VoidTypeAnnotation": ++ return "void"; ++ ++ case "InferredPredicate": ++ return "%checks"; ++ // Unhandled types below. If encountered, nodes of these types should ++ // be either left alone or desugared into AST types that are fully ++ // supported by the pretty-printer. ++ ++ case "DeclaredPredicate": ++ return concat$6(["%checks(", path.call(print, "value"), ")"]); ++ ++ case "TSAbstractKeyword": ++ return "abstract"; ++ ++ case "TSAnyKeyword": ++ return "any"; ++ ++ case "TSAsyncKeyword": ++ return "async"; ++ ++ case "TSBooleanKeyword": ++ return "boolean"; ++ ++ case "TSBigIntKeyword": ++ return "bigint"; ++ ++ case "TSConstKeyword": ++ return "const"; ++ ++ case "TSDeclareKeyword": ++ return "declare"; ++ ++ case "TSExportKeyword": ++ return "export"; ++ ++ case "TSNeverKeyword": ++ return "never"; ++ ++ case "TSNumberKeyword": ++ return "number"; ++ ++ case "TSObjectKeyword": ++ return "object"; ++ ++ case "TSProtectedKeyword": ++ return "protected"; ++ ++ case "TSPrivateKeyword": ++ return "private"; ++ ++ case "TSPublicKeyword": ++ return "public"; ++ ++ case "TSReadonlyKeyword": ++ return "readonly"; ++ ++ case "TSSymbolKeyword": ++ return "symbol"; ++ ++ case "TSStaticKeyword": ++ return "static"; ++ ++ case "TSStringKeyword": ++ return "string"; ++ ++ case "TSUndefinedKeyword": ++ return "undefined"; ++ ++ case "TSUnknownKeyword": ++ return "unknown"; ++ ++ case "TSVoidKeyword": ++ return "void"; ++ ++ case "TSAsExpression": ++ return concat$6([path.call(print, "expression"), " as ", path.call(print, "typeAnnotation")]); ++ ++ case "TSArrayType": ++ return concat$6([path.call(print, "elementType"), "[]"]); ++ ++ case "TSPropertySignature": ++ { ++ if (n.export) { ++ parts.push("export "); ++ } ++ ++ if (n.accessibility) { ++ parts.push(n.accessibility + " "); ++ } ++ ++ if (n.static) { ++ parts.push("static "); ++ } ++ ++ if (n.readonly) { ++ parts.push("readonly "); ++ } ++ ++ parts.push(printPropertyKey(path, options, print), printOptionalToken(path)); ++ ++ if (n.typeAnnotation) { ++ parts.push(": "); ++ parts.push(path.call(print, "typeAnnotation")); ++ } // This isn't valid semantically, but it's in the AST so we can print it. ++ ++ ++ if (n.initializer) { ++ parts.push(" = ", path.call(print, "initializer")); ++ } ++ ++ return concat$6(parts); ++ } ++ ++ case "TSParameterProperty": ++ if (n.accessibility) { ++ parts.push(n.accessibility + " "); ++ } ++ ++ if (n.export) { ++ parts.push("export "); ++ } ++ ++ if (n.static) { ++ parts.push("static "); ++ } ++ ++ if (n.readonly) { ++ parts.push("readonly "); ++ } ++ ++ parts.push(path.call(print, "parameter")); ++ return concat$6(parts); ++ ++ case "TSTypeReference": ++ return concat$6([path.call(print, "typeName"), printTypeParameters(path, options, print, "typeParameters")]); ++ ++ case "TSTypeQuery": ++ return concat$6(["typeof ", path.call(print, "exprName")]); ++ ++ case "TSIndexSignature": ++ { ++ const parent = path.getParentNode(); // The typescript parser accepts multiple parameters here. If you're ++ // using them, it makes sense to have a trailing comma. But if you ++ // aren't, this is more like a computed property name than an array. ++ // So we leave off the trailing comma when there's just one parameter. ++ ++ const trailingComma = n.parameters.length > 1 ? ifBreak$1(shouldPrintComma(options) ? "," : "") : ""; ++ const parametersGroup = group$2(concat$6([indent$3(concat$6([softline$2, join$4(concat$6([", ", softline$2]), path.map(print, "parameters"))])), trailingComma, softline$2])); ++ return concat$6([n.export ? "export " : "", n.accessibility ? concat$6([n.accessibility, " "]) : "", n.static ? "static " : "", n.readonly ? "readonly " : "", "[", n.parameters ? parametersGroup : "", n.typeAnnotation ? "]: " : "]", n.typeAnnotation ? path.call(print, "typeAnnotation") : "", parent.type === "ClassBody" ? semi : ""]); ++ } ++ ++ case "TSTypePredicate": ++ return concat$6([n.asserts ? "asserts " : "", path.call(print, "parameterName"), n.typeAnnotation ? concat$6([" is ", path.call(print, "typeAnnotation")]) : ""]); ++ ++ case "TSNonNullExpression": ++ return concat$6([path.call(print, "expression"), "!"]); ++ ++ case "TSThisType": ++ return "this"; ++ ++ case "TSImportType": ++ return concat$6([!n.isTypeOf ? "" : "typeof ", "import(", path.call(print, n.parameter ? "parameter" : "argument"), ")", !n.qualifier ? "" : concat$6([".", path.call(print, "qualifier")]), printTypeParameters(path, options, print, "typeParameters")]); ++ ++ case "TSLiteralType": ++ return path.call(print, "literal"); ++ ++ case "TSIndexedAccessType": ++ return concat$6([path.call(print, "objectType"), "[", path.call(print, "indexType"), "]"]); ++ ++ case "TSConstructSignatureDeclaration": ++ case "TSCallSignatureDeclaration": ++ case "TSConstructorType": ++ { ++ if (n.type !== "TSCallSignatureDeclaration") { ++ parts.push("new "); ++ } ++ ++ parts.push(group$2(printFunctionParams(path, print, options, ++ /* expandArg */ ++ false, ++ /* printTypeParams */ ++ true))); ++ ++ if (n.returnType || n.typeAnnotation) { ++ const isType = n.type === "TSConstructorType"; ++ parts.push(isType ? " => " : ": ", path.call(print, "returnType"), path.call(print, "typeAnnotation")); ++ } ++ ++ return concat$6(parts); ++ } ++ ++ case "TSTypeOperator": ++ return concat$6([n.operator, " ", path.call(print, "typeAnnotation")]); ++ ++ case "TSMappedType": ++ { ++ const shouldBreak = hasNewlineInRange$3(options.originalText, options.locStart(n), options.locEnd(n)); ++ return group$2(concat$6(["{", indent$3(concat$6([options.bracketSpacing ? line$4 : softline$2, n.readonly ? concat$6([getTypeScriptMappedTypeModifier$1(n.readonly, "readonly"), " "]) : "", printTypeScriptModifiers(path, options, print), path.call(print, "typeParameter"), n.optional ? getTypeScriptMappedTypeModifier$1(n.optional, "?") : "", n.typeAnnotation ? ": " : "", path.call(print, "typeAnnotation"), ifBreak$1(semi, "")])), comments.printDanglingComments(path, options, ++ /* sameIndent */ ++ true), options.bracketSpacing ? line$4 : softline$2, "}"]), { ++ shouldBreak ++ }); ++ } ++ ++ case "TSMethodSignature": ++ parts.push(n.accessibility ? concat$6([n.accessibility, " "]) : "", n.export ? "export " : "", n.static ? "static " : "", n.readonly ? "readonly " : "", n.computed ? "[" : "", path.call(print, "key"), n.computed ? "]" : "", printOptionalToken(path), printFunctionParams(path, print, options, ++ /* expandArg */ ++ false, ++ /* printTypeParams */ ++ true)); ++ ++ if (n.returnType || n.typeAnnotation) { ++ parts.push(": ", path.call(print, "returnType"), path.call(print, "typeAnnotation")); ++ } ++ ++ return group$2(concat$6(parts)); ++ ++ case "TSNamespaceExportDeclaration": ++ parts.push("export as namespace ", path.call(print, "id")); ++ ++ if (options.semi) { ++ parts.push(";"); ++ } ++ ++ return group$2(concat$6(parts)); ++ ++ case "TSEnumDeclaration": ++ if (n.declare) { ++ parts.push("declare "); ++ } ++ ++ if (n.modifiers) { ++ parts.push(printTypeScriptModifiers(path, options, print)); ++ } ++ ++ if (n.const) { ++ parts.push("const "); ++ } ++ ++ parts.push("enum ", path.call(print, "id"), " "); ++ ++ if (n.members.length === 0) { ++ parts.push(group$2(concat$6(["{", comments.printDanglingComments(path, options), softline$2, "}"]))); ++ } else { ++ parts.push(group$2(concat$6(["{", indent$3(concat$6([hardline$4, printArrayItems(path, options, "members", print), shouldPrintComma(options, "es5") ? "," : ""])), comments.printDanglingComments(path, options, ++ /* sameIndent */ ++ true), hardline$4, "}"]))); ++ } ++ ++ return concat$6(parts); ++ ++ case "TSEnumMember": ++ parts.push(path.call(print, "id")); ++ ++ if (n.initializer) { ++ parts.push(" = ", path.call(print, "initializer")); ++ } ++ ++ return concat$6(parts); ++ ++ case "TSImportEqualsDeclaration": ++ if (n.isExport) { ++ parts.push("export "); ++ } ++ ++ parts.push("import ", path.call(print, "id"), " = ", path.call(print, "moduleReference")); ++ ++ if (options.semi) { ++ parts.push(";"); ++ } ++ ++ return group$2(concat$6(parts)); ++ ++ case "TSExternalModuleReference": ++ return concat$6(["require(", path.call(print, "expression"), ")"]); ++ ++ case "TSModuleDeclaration": ++ { ++ const parent = path.getParentNode(); ++ const isExternalModule = isLiteral$1(n.id); ++ const parentIsDeclaration = parent.type === "TSModuleDeclaration"; ++ const bodyIsDeclaration = n.body && n.body.type === "TSModuleDeclaration"; ++ ++ if (parentIsDeclaration) { ++ parts.push("."); ++ } else { ++ if (n.declare) { ++ parts.push("declare "); ++ } ++ ++ parts.push(printTypeScriptModifiers(path, options, print)); ++ const textBetweenNodeAndItsId = options.originalText.slice(options.locStart(n), options.locStart(n.id)); // Global declaration looks like this: ++ // (declare)? global { ... } ++ ++ const isGlobalDeclaration = n.id.type === "Identifier" && n.id.name === "global" && !/namespace|module/.test(textBetweenNodeAndItsId); ++ ++ if (!isGlobalDeclaration) { ++ parts.push(isExternalModule || /(^|\s)module(\s|$)/.test(textBetweenNodeAndItsId) ? "module " : "namespace "); ++ } ++ } ++ ++ parts.push(path.call(print, "id")); ++ ++ if (bodyIsDeclaration) { ++ parts.push(path.call(print, "body")); ++ } else if (n.body) { ++ parts.push(" ", group$2(path.call(print, "body"))); ++ } else { ++ parts.push(semi); ++ } ++ ++ return concat$6(parts); ++ } ++ ++ case "PrivateName": ++ return concat$6(["#", path.call(print, "id")]); ++ // TODO: Temporary auto-generated node type. To remove when typescript-estree has proper support for private fields. ++ ++ case "TSPrivateIdentifier": ++ return n.escapedText; ++ ++ case "TSConditionalType": ++ return printTernaryOperator(path, options, print, { ++ beforeParts: () => [path.call(print, "checkType"), " ", "extends", " ", path.call(print, "extendsType")], ++ afterParts: () => [], ++ shouldCheckJsx: false, ++ conditionalNodeType: "TSConditionalType", ++ consequentNodePropertyName: "trueType", ++ alternateNodePropertyName: "falseType", ++ testNodePropertyNames: ["checkType", "extendsType"] ++ }); ++ ++ case "TSInferType": ++ return concat$6(["infer", " ", path.call(print, "typeParameter")]); ++ ++ case "InterpreterDirective": ++ parts.push("#!", n.value, hardline$4); ++ ++ if (isNextLineEmpty$2(options.originalText, n, options.locEnd)) { ++ parts.push(hardline$4); ++ } ++ ++ return concat$6(parts); ++ ++ case "NGRoot": ++ return concat$6([].concat(path.call(print, "node"), !n.node.comments || n.node.comments.length === 0 ? [] : concat$6([" //", n.node.comments[0].value.trimEnd()]))); ++ ++ case "NGChainedExpression": ++ return group$2(join$4(concat$6([";", line$4]), path.map(childPath => hasNgSideEffect$1(childPath) ? print(childPath) : concat$6(["(", print(childPath), ")"]), "expressions"))); ++ ++ case "NGEmptyExpression": ++ return ""; ++ ++ case "NGQuotedExpression": ++ return concat$6([n.prefix, ":", n.value]); ++ ++ case "NGMicrosyntax": ++ return concat$6(path.map((childPath, index) => concat$6([index === 0 ? "" : isNgForOf$1(childPath.getValue(), index, n) ? " " : concat$6([";", line$4]), print(childPath)]), "body")); ++ ++ case "NGMicrosyntaxKey": ++ return /^[a-z_$][a-z0-9_$]*(-[a-z_$][a-z0-9_$])*$/i.test(n.name) ? n.name : JSON.stringify(n.name); ++ ++ case "NGMicrosyntaxExpression": ++ return concat$6([path.call(print, "expression"), n.alias === null ? "" : concat$6([" as ", path.call(print, "alias")])]); ++ ++ case "NGMicrosyntaxKeyedExpression": ++ { ++ const index = path.getName(); ++ const parentNode = path.getParentNode(); ++ const shouldNotPrintColon = isNgForOf$1(n, index, parentNode) || (index === 1 && (n.key.name === "then" || n.key.name === "else") || index === 2 && n.key.name === "else" && parentNode.body[index - 1].type === "NGMicrosyntaxKeyedExpression" && parentNode.body[index - 1].key.name === "then") && parentNode.body[0].type === "NGMicrosyntaxExpression"; ++ return concat$6([path.call(print, "key"), shouldNotPrintColon ? " " : ": ", path.call(print, "expression")]); ++ } ++ ++ case "NGMicrosyntaxLet": ++ return concat$6(["let ", path.call(print, "key"), n.value === null ? "" : concat$6([" = ", path.call(print, "value")])]); ++ ++ case "NGMicrosyntaxAs": ++ return concat$6([path.call(print, "key"), " as ", path.call(print, "alias")]); ++ ++ case "ArgumentPlaceholder": ++ return "?"; ++ // These are not valid TypeScript. Printing them just for the sake of error recovery. ++ ++ case "TSJSDocAllType": ++ return "*"; ++ ++ case "TSJSDocUnknownType": ++ return "?"; ++ ++ case "TSJSDocNullableType": ++ return concat$6(["?", path.call(print, "typeAnnotation")]); ++ ++ case "TSJSDocNonNullableType": ++ return concat$6(["!", path.call(print, "typeAnnotation")]); ++ ++ case "TSJSDocFunctionType": ++ return concat$6(["function(", // The parameters could be here, but typescript-estree doesn't convert them anyway (throws an error). ++ "): ", path.call(print, "typeAnnotation")]); ++ ++ default: ++ /* istanbul ignore next */ ++ throw new Error("unknown type: " + JSON.stringify(n.type)); ++ } ++} ++ ++function printStatementSequence(path, options, print) { ++ const printed = []; ++ const bodyNode = path.getNode(); ++ const isClass = bodyNode.type === "ClassBody"; ++ path.map((stmtPath, i) => { ++ const stmt = stmtPath.getValue(); // Just in case the AST has been modified to contain falsy ++ // "statements," it's safer simply to skip them. ++ ++ /* istanbul ignore if */ ++ ++ if (!stmt) { ++ return; ++ } // Skip printing EmptyStatement nodes to avoid leaving stray ++ // semicolons lying around. ++ ++ ++ if (stmt.type === "EmptyStatement") { ++ return; ++ } ++ ++ const stmtPrinted = print(stmtPath); ++ const text = options.originalText; ++ const parts = []; // in no-semi mode, prepend statement with semicolon if it might break ASI ++ // don't prepend the only JSX element in a program with semicolon ++ ++ if (!options.semi && !isClass && !isTheOnlyJSXElementInMarkdown$1(options, stmtPath) && stmtNeedsASIProtection(stmtPath, options)) { ++ if (stmt.comments && stmt.comments.some(comment => comment.leading)) { ++ parts.push(print(stmtPath, { ++ needsSemi: true ++ })); ++ } else { ++ parts.push(";", stmtPrinted); ++ } ++ } else { ++ parts.push(stmtPrinted); ++ } ++ ++ if (!options.semi && isClass) { ++ if (classPropMayCauseASIProblems$1(stmtPath)) { ++ parts.push(";"); ++ } else if (stmt.type === "ClassProperty") { ++ const nextChild = bodyNode.body[i + 1]; ++ ++ if (classChildNeedsASIProtection$1(nextChild)) { ++ parts.push(";"); ++ } ++ } ++ } ++ ++ if (isNextLineEmpty$2(text, stmt, options.locEnd) && !isLastStatement$1(stmtPath)) { ++ parts.push(hardline$4); ++ } ++ ++ printed.push(concat$6(parts)); ++ }); ++ return join$4(hardline$4, printed); ++} ++ ++function printPropertyKey(path, options, print) { ++ const node = path.getNode(); ++ ++ if (node.computed) { ++ return concat$6(["[", path.call(print, "key"), "]"]); ++ } ++ ++ const parent = path.getParentNode(); ++ const { ++ key ++ } = node; ++ ++ if (node.type === "ClassPrivateProperty" && // flow has `Identifier` key, and babel has `PrivateName` key ++ key.type === "Identifier") { ++ return concat$6(["#", path.call(print, "key")]); ++ } ++ ++ if (options.quoteProps === "consistent" && !needsQuoteProps.has(parent)) { ++ const objectHasStringProp = (parent.properties || parent.body || parent.members).some(prop => !prop.computed && prop.key && isStringLiteral$1(prop.key) && !isStringPropSafeToCoerceToIdentifier$1(prop, options)); ++ needsQuoteProps.set(parent, objectHasStringProp); ++ } ++ ++ if (key.type === "Identifier" && (options.parser === "json" || options.quoteProps === "consistent" && needsQuoteProps.get(parent))) { ++ // a -> "a" ++ const prop = printString$1(JSON.stringify(key.name), options); ++ return path.call(keyPath => comments.printComments(keyPath, () => prop, options), "key"); ++ } ++ ++ if (isStringPropSafeToCoerceToIdentifier$1(node, options) && (options.quoteProps === "as-needed" || options.quoteProps === "consistent" && !needsQuoteProps.get(parent))) { ++ // 'a' -> a ++ return path.call(keyPath => comments.printComments(keyPath, () => key.value, options), "key"); ++ } ++ ++ return path.call(print, "key"); ++} ++ ++function printMethod(path, options, print) { ++ const node = path.getNode(); ++ const { ++ kind ++ } = node; ++ const value = node.value || node; ++ const parts = []; ++ ++ if (!kind || kind === "init" || kind === "method" || kind === "constructor") { ++ if (value.async) { ++ parts.push("async "); ++ } ++ ++ if (value.generator) { ++ parts.push("*"); ++ } ++ } else { ++ assert.ok(kind === "get" || kind === "set"); ++ parts.push(kind, " "); ++ } ++ ++ parts.push(printPropertyKey(path, options, print), node.optional || node.key.optional ? "?" : "", node === value ? printMethodInternal(path, options, print) : path.call(path => printMethodInternal(path, options, print), "value")); ++ return concat$6(parts); ++} ++ ++function printMethodInternal(path, options, print) { ++ const parts = [printFunctionTypeParameters(path, options, print), group$2(concat$6([printFunctionParams(path, print, options), printReturnType(path, print, options)]))]; ++ ++ if (path.getNode().body) { ++ parts.push(" ", path.call(print, "body")); ++ } else { ++ parts.push(options.semi ? ";" : ""); ++ } ++ ++ return concat$6(parts); ++} ++ ++function couldGroupArg(arg) { ++ return arg.type === "ObjectExpression" && (arg.properties.length > 0 || arg.comments) || arg.type === "ArrayExpression" && (arg.elements.length > 0 || arg.comments) || arg.type === "TSTypeAssertion" && couldGroupArg(arg.expression) || arg.type === "TSAsExpression" && couldGroupArg(arg.expression) || arg.type === "FunctionExpression" || arg.type === "ArrowFunctionExpression" && ( // we want to avoid breaking inside composite return types but not simple keywords ++ // https://github.com/prettier/prettier/issues/4070 ++ // export class Thing implements OtherThing { ++ // do: (type: Type) => Provider = memoize( ++ // (type: ObjectType): Provider => {} ++ // ); ++ // } ++ // https://github.com/prettier/prettier/issues/6099 ++ // app.get("/", (req, res): void => { ++ // res.send("Hello World!"); ++ // }); ++ !arg.returnType || !arg.returnType.typeAnnotation || arg.returnType.typeAnnotation.type !== "TSTypeReference") && (arg.body.type === "BlockStatement" || arg.body.type === "ArrowFunctionExpression" || arg.body.type === "ObjectExpression" || arg.body.type === "ArrayExpression" || arg.body.type === "CallExpression" || arg.body.type === "OptionalCallExpression" || arg.body.type === "ConditionalExpression" || isJSXNode$1(arg.body)); ++} ++ ++function shouldGroupLastArg(args) { ++ const lastArg = getLast$2(args); ++ const penultimateArg = getPenultimate$1(args); ++ return !hasLeadingComment$3(lastArg) && !hasTrailingComment$1(lastArg) && couldGroupArg(lastArg) && ( // If the last two arguments are of the same type, ++ // disable last element expansion. ++ !penultimateArg || penultimateArg.type !== lastArg.type); ++} ++ ++function shouldGroupFirstArg(args) { ++ if (args.length !== 2) { ++ return false; ++ } ++ ++ const [firstArg, secondArg] = args; ++ return (!firstArg.comments || !firstArg.comments.length) && (firstArg.type === "FunctionExpression" || firstArg.type === "ArrowFunctionExpression" && firstArg.body.type === "BlockStatement") && secondArg.type !== "FunctionExpression" && secondArg.type !== "ArrowFunctionExpression" && secondArg.type !== "ConditionalExpression" && !couldGroupArg(secondArg); ++} ++ ++function printJestEachTemplateLiteral(node, expressions, options) { ++ /** ++ * a | b | expected ++ * ${1} | ${1} | ${2} ++ * ${1} | ${2} | ${3} ++ * ${2} | ${1} | ${3} ++ */ ++ const headerNames = node.quasis[0].value.raw.trim().split(/\s*\|\s*/); ++ ++ if (headerNames.length > 1 || headerNames.some(headerName => headerName.length !== 0)) { ++ const parts = []; ++ const stringifiedExpressions = expressions.map(doc => "${" + printDocToString$2(doc, Object.assign({}, options, { ++ printWidth: Infinity, ++ endOfLine: "lf" ++ })).formatted + "}"); ++ const tableBody = [{ ++ hasLineBreak: false, ++ cells: [] ++ }]; ++ ++ for (let i = 1; i < node.quasis.length; i++) { ++ const row = tableBody[tableBody.length - 1]; ++ const correspondingExpression = stringifiedExpressions[i - 1]; ++ row.cells.push(correspondingExpression); ++ ++ if (correspondingExpression.includes("\n")) { ++ row.hasLineBreak = true; ++ } ++ ++ if (node.quasis[i].value.raw.includes("\n")) { ++ tableBody.push({ ++ hasLineBreak: false, ++ cells: [] ++ }); ++ } ++ } ++ ++ const maxColumnCount = Math.max(headerNames.length, ...tableBody.map(row => row.cells.length)); ++ const maxColumnWidths = Array.from({ ++ length: maxColumnCount ++ }).fill(0); ++ const table = [{ ++ cells: headerNames ++ }, ...tableBody.filter(row => row.cells.length !== 0)]; ++ ++ for (const { ++ cells ++ } of table.filter(row => !row.hasLineBreak)) { ++ cells.forEach((cell, index) => { ++ maxColumnWidths[index] = Math.max(maxColumnWidths[index], getStringWidth$3(cell)); ++ }); ++ } ++ ++ parts.push(lineSuffixBoundary$1, "`", indent$3(concat$6([hardline$4, join$4(hardline$4, table.map(row => join$4(" | ", row.cells.map((cell, index) => row.hasLineBreak ? cell : cell + " ".repeat(maxColumnWidths[index] - getStringWidth$3(cell))))))])), hardline$4, "`"); ++ return concat$6(parts); ++ } ++} ++ ++function printArgumentsList(path, options, print) { ++ const node = path.getValue(); ++ const args = node.arguments; ++ ++ if (args.length === 0) { ++ return concat$6(["(", comments.printDanglingComments(path, options, ++ /* sameIndent */ ++ true), ")"]); ++ } // useEffect(() => { ... }, [foo, bar, baz]) ++ ++ ++ if (args.length === 2 && args[0].type === "ArrowFunctionExpression" && args[0].params.length === 0 && args[0].body.type === "BlockStatement" && args[1].type === "ArrayExpression" && !args.find(arg => arg.comments)) { ++ return concat$6(["(", path.call(print, "arguments", 0), ", ", path.call(print, "arguments", 1), ")"]); ++ } // func( ++ // ({ ++ // a, ++ // b ++ // }) => {} ++ // ); ++ ++ ++ function shouldBreakForArrowFunctionInArguments(arg, argPath) { ++ if (!arg || arg.type !== "ArrowFunctionExpression" || !arg.body || arg.body.type !== "BlockStatement" || !arg.params || arg.params.length < 1) { ++ return false; ++ } ++ ++ let shouldBreak = false; ++ argPath.each(paramPath => { ++ const printed = concat$6([print(paramPath)]); ++ shouldBreak = shouldBreak || willBreak$1(printed); ++ }, "params"); ++ return shouldBreak; ++ } ++ ++ let anyArgEmptyLine = false; ++ let shouldBreakForArrowFunction = false; ++ let hasEmptyLineFollowingFirstArg = false; ++ const lastArgIndex = args.length - 1; ++ const printedArguments = path.map((argPath, index) => { ++ const arg = argPath.getNode(); ++ const parts = [print(argPath)]; ++ ++ if (index === lastArgIndex) ; else if (isNextLineEmpty$2(options.originalText, arg, options.locEnd)) { ++ if (index === 0) { ++ hasEmptyLineFollowingFirstArg = true; ++ } ++ ++ anyArgEmptyLine = true; ++ parts.push(",", hardline$4, hardline$4); ++ } else { ++ parts.push(",", line$4); ++ } ++ ++ shouldBreakForArrowFunction = shouldBreakForArrowFunctionInArguments(arg, argPath); ++ return concat$6(parts); ++ }, "arguments"); ++ const maybeTrailingComma = // Dynamic imports cannot have trailing commas ++ !(node.callee && node.callee.type === "Import") && shouldPrintComma(options, "all") ? "," : ""; ++ ++ function allArgsBrokenOut() { ++ return group$2(concat$6(["(", indent$3(concat$6([line$4, concat$6(printedArguments)])), maybeTrailingComma, line$4, ")"]), { ++ shouldBreak: true ++ }); ++ } ++ ++ if (path.getParentNode().type !== "Decorator" && isFunctionCompositionArgs$1(args)) { ++ return allArgsBrokenOut(); ++ } ++ ++ const shouldGroupFirst = shouldGroupFirstArg(args); ++ const shouldGroupLast = shouldGroupLastArg(args); ++ ++ if (shouldGroupFirst || shouldGroupLast) { ++ const shouldBreak = (shouldGroupFirst ? printedArguments.slice(1).some(willBreak$1) : printedArguments.slice(0, -1).some(willBreak$1)) || anyArgEmptyLine || shouldBreakForArrowFunction; // We want to print the last argument with a special flag ++ ++ let printedExpanded; ++ let i = 0; ++ path.each(argPath => { ++ if (shouldGroupFirst && i === 0) { ++ printedExpanded = [concat$6([argPath.call(p => print(p, { ++ expandFirstArg: true ++ })), printedArguments.length > 1 ? "," : "", hasEmptyLineFollowingFirstArg ? hardline$4 : line$4, hasEmptyLineFollowingFirstArg ? hardline$4 : ""])].concat(printedArguments.slice(1)); ++ } ++ ++ if (shouldGroupLast && i === args.length - 1) { ++ printedExpanded = printedArguments.slice(0, -1).concat(argPath.call(p => print(p, { ++ expandLastArg: true ++ }))); ++ } ++ ++ i++; ++ }, "arguments"); ++ const somePrintedArgumentsWillBreak = printedArguments.some(willBreak$1); ++ const simpleConcat = concat$6(["(", concat$6(printedExpanded), ")"]); ++ return concat$6([somePrintedArgumentsWillBreak ? breakParent$2 : "", conditionalGroup$1([!somePrintedArgumentsWillBreak && !node.typeArguments && !node.typeParameters ? simpleConcat : ifBreak$1(allArgsBrokenOut(), simpleConcat), shouldGroupFirst ? concat$6(["(", group$2(printedExpanded[0], { ++ shouldBreak: true ++ }), concat$6(printedExpanded.slice(1)), ")"]) : concat$6(["(", concat$6(printedArguments.slice(0, -1)), group$2(getLast$2(printedExpanded), { ++ shouldBreak: true ++ }), ")"]), allArgsBrokenOut()], { ++ shouldBreak ++ })]); ++ } ++ ++ const contents = concat$6(["(", indent$3(concat$6([softline$2, concat$6(printedArguments)])), ifBreak$1(maybeTrailingComma), softline$2, ")"]); ++ ++ if (isLongCurriedCallExpression$1(path)) { ++ // By not wrapping the arguments in a group, the printer prioritizes ++ // breaking up these arguments rather than the args of the parent call. ++ return contents; ++ } ++ ++ return group$2(contents, { ++ shouldBreak: printedArguments.some(willBreak$1) || anyArgEmptyLine ++ }); ++} ++ ++function printTypeAnnotation(path, options, print) { ++ const node = path.getValue(); ++ ++ if (!node.typeAnnotation) { ++ return ""; ++ } ++ ++ const parentNode = path.getParentNode(); ++ const isDefinite = node.definite || parentNode && parentNode.type === "VariableDeclarator" && parentNode.definite; ++ const isFunctionDeclarationIdentifier = parentNode.type === "DeclareFunction" && parentNode.id === node; ++ ++ if (isFlowAnnotationComment$1(options.originalText, node.typeAnnotation, options)) { ++ return concat$6([" /*: ", path.call(print, "typeAnnotation"), " */"]); ++ } ++ ++ return concat$6([isFunctionDeclarationIdentifier ? "" : isDefinite ? "!: " : ": ", path.call(print, "typeAnnotation")]); ++} ++ ++function printFunctionTypeParameters(path, options, print) { ++ const fun = path.getValue(); ++ ++ if (fun.typeArguments) { ++ return path.call(print, "typeArguments"); ++ } ++ ++ if (fun.typeParameters) { ++ return path.call(print, "typeParameters"); ++ } ++ ++ return ""; ++} ++ ++function printFunctionParams(path, print, options, expandArg, printTypeParams) { ++ const fun = path.getValue(); ++ const parent = path.getParentNode(); ++ const paramsField = fun.parameters ? "parameters" : "params"; ++ const isParametersInTestCall = isTestCall$1(parent); ++ const shouldHugParameters = shouldHugArguments(fun); ++ const shouldExpandParameters = expandArg && !(fun[paramsField] && fun[paramsField].some(n => n.comments)); ++ const typeParams = printTypeParams ? printFunctionTypeParameters(path, options, print) : ""; ++ let printed = []; ++ ++ if (fun[paramsField]) { ++ const lastArgIndex = fun[paramsField].length - 1; ++ printed = path.map((childPath, index) => { ++ const parts = []; ++ const param = childPath.getValue(); ++ parts.push(print(childPath)); ++ ++ if (index === lastArgIndex) { ++ if (fun.rest) { ++ parts.push(",", line$4); ++ } ++ } else if (isParametersInTestCall || shouldHugParameters || shouldExpandParameters) { ++ parts.push(", "); ++ } else if (isNextLineEmpty$2(options.originalText, param, options.locEnd)) { ++ parts.push(",", hardline$4, hardline$4); ++ } else { ++ parts.push(",", line$4); ++ } ++ ++ return concat$6(parts); ++ }, paramsField); ++ } ++ ++ if (fun.rest) { ++ printed.push(concat$6(["...", path.call(print, "rest")])); ++ } ++ ++ if (printed.length === 0) { ++ return concat$6([typeParams, "(", comments.printDanglingComments(path, options, ++ /* sameIndent */ ++ true, comment => getNextNonSpaceNonCommentCharacter$1(options.originalText, comment, options.locEnd) === ")"), ")"]); ++ } ++ ++ const lastParam = getLast$2(fun[paramsField]); // If the parent is a call with the first/last argument expansion and this is the ++ // params of the first/last argument, we don't want the arguments to break and instead ++ // want the whole expression to be on a new line. ++ // ++ // Good: Bad: ++ // verylongcall( verylongcall(( ++ // (a, b) => { a, ++ // } b, ++ // }) ) => { ++ // }) ++ ++ if (shouldExpandParameters) { ++ return group$2(concat$6([removeLines$1(typeParams), "(", concat$6(printed.map(removeLines$1)), ")"])); ++ } // Single object destructuring should hug ++ // ++ // function({ ++ // a, ++ // b, ++ // c ++ // }) {} ++ ++ ++ const hasNotParameterDecorator = fun[paramsField].every(param => !param.decorators); ++ ++ if (shouldHugParameters && hasNotParameterDecorator) { ++ return concat$6([typeParams, "(", concat$6(printed), ")"]); ++ } // don't break in specs, eg; `it("should maintain parens around done even when long", (done) => {})` ++ ++ ++ if (isParametersInTestCall) { ++ return concat$6([typeParams, "(", concat$6(printed), ")"]); ++ } ++ ++ const isFlowShorthandWithOneArg = (isObjectTypePropertyAFunction$1(parent, options) || isTypeAnnotationAFunction$1(parent, options) || parent.type === "TypeAlias" || parent.type === "UnionTypeAnnotation" || parent.type === "TSUnionType" || parent.type === "IntersectionTypeAnnotation" || parent.type === "FunctionTypeAnnotation" && parent.returnType === fun) && fun[paramsField].length === 1 && fun[paramsField][0].name === null && fun[paramsField][0].typeAnnotation && fun.typeParameters === null && isSimpleFlowType$1(fun[paramsField][0].typeAnnotation) && !fun.rest; ++ ++ if (isFlowShorthandWithOneArg) { ++ if (options.arrowParens === "always") { ++ return concat$6(["(", concat$6(printed), ")"]); ++ } ++ ++ return concat$6(printed); ++ } ++ ++ const canHaveTrailingComma = !(lastParam && lastParam.type === "RestElement") && !fun.rest; ++ return concat$6([typeParams, "(", indent$3(concat$6([softline$2, concat$6(printed)])), ifBreak$1(canHaveTrailingComma && shouldPrintComma(options, "all") ? "," : ""), softline$2, ")"]); ++} ++ ++function shouldPrintParamsWithoutParens(path, options) { ++ if (options.arrowParens === "always") { ++ return false; ++ } ++ ++ if (options.arrowParens === "avoid") { ++ const node = path.getValue(); ++ return canPrintParamsWithoutParens(node); ++ } // Fallback default; should be unreachable ++ ++ ++ return false; ++} ++ ++function canPrintParamsWithoutParens(node) { ++ return node.params.length === 1 && !node.rest && !node.typeParameters && !hasDanglingComments$1(node) && node.params[0].type === "Identifier" && !node.params[0].typeAnnotation && !node.params[0].comments && !node.params[0].optional && !node.predicate && !node.returnType; ++} ++ ++function printFunctionDeclaration(path, print, options) { ++ const n = path.getValue(); ++ const parts = []; ++ ++ if (n.async) { ++ parts.push("async "); ++ } ++ ++ if (n.generator) { ++ parts.push("function* "); ++ } else { ++ parts.push("function "); ++ } ++ ++ if (n.id) { ++ parts.push(path.call(print, "id")); ++ } ++ ++ parts.push(printFunctionTypeParameters(path, options, print), group$2(concat$6([printFunctionParams(path, print, options), printReturnType(path, print, options)])), n.body ? " " : "", path.call(print, "body")); ++ return concat$6(parts); ++} ++ ++function printReturnType(path, print, options) { ++ const n = path.getValue(); ++ const returnType = path.call(print, "returnType"); ++ ++ if (n.returnType && isFlowAnnotationComment$1(options.originalText, n.returnType, options)) { ++ return concat$6([" /*: ", returnType, " */"]); ++ } ++ ++ const parts = [returnType]; // prepend colon to TypeScript type annotation ++ ++ if (n.returnType && n.returnType.typeAnnotation) { ++ parts.unshift(": "); ++ } ++ ++ if (n.predicate) { ++ // The return type will already add the colon, but otherwise we ++ // need to do it ourselves ++ parts.push(n.returnType ? " " : ": ", path.call(print, "predicate")); ++ } ++ ++ return concat$6(parts); ++} ++ ++function printExportDeclaration(path, options, print) { ++ const decl = path.getValue(); ++ const semi = options.semi ? ";" : ""; ++ const parts = ["export "]; ++ const isDefault = decl.default || decl.type === "ExportDefaultDeclaration"; ++ ++ if (isDefault) { ++ parts.push("default "); ++ } ++ ++ parts.push(comments.printDanglingComments(path, options, ++ /* sameIndent */ ++ true)); ++ ++ if (needsHardlineAfterDanglingComment$1(decl)) { ++ parts.push(hardline$4); ++ } ++ ++ if (decl.declaration) { ++ parts.push(path.call(print, "declaration")); ++ ++ if (isDefault && decl.declaration.type !== "ClassDeclaration" && decl.declaration.type !== "FunctionDeclaration" && decl.declaration.type !== "TSInterfaceDeclaration" && decl.declaration.type !== "DeclareClass" && decl.declaration.type !== "DeclareFunction" && decl.declaration.type !== "TSDeclareFunction") { ++ parts.push(semi); ++ } ++ } else { ++ if (decl.specifiers && decl.specifiers.length > 0) { ++ const specifiers = []; ++ const defaultSpecifiers = []; ++ const namespaceSpecifiers = []; ++ path.each(specifierPath => { ++ const specifierType = path.getValue().type; ++ ++ if (specifierType === "ExportSpecifier") { ++ specifiers.push(print(specifierPath)); ++ } else if (specifierType === "ExportDefaultSpecifier") { ++ defaultSpecifiers.push(print(specifierPath)); ++ } else if (specifierType === "ExportNamespaceSpecifier") { ++ namespaceSpecifiers.push(concat$6(["* as ", print(specifierPath)])); ++ } ++ }, "specifiers"); ++ const isNamespaceFollowed = namespaceSpecifiers.length !== 0 && specifiers.length !== 0; ++ const isDefaultFollowed = defaultSpecifiers.length !== 0 && (namespaceSpecifiers.length !== 0 || specifiers.length !== 0); ++ const canBreak = specifiers.length > 1 || defaultSpecifiers.length > 0 || decl.specifiers && decl.specifiers.some(node => node.comments); ++ let printed = ""; ++ ++ if (specifiers.length !== 0) { ++ if (canBreak) { ++ printed = group$2(concat$6(["{", indent$3(concat$6([options.bracketSpacing ? line$4 : softline$2, join$4(concat$6([",", line$4]), specifiers)])), ifBreak$1(shouldPrintComma(options) ? "," : ""), options.bracketSpacing ? line$4 : softline$2, "}"])); ++ } else { ++ printed = concat$6(["{", options.bracketSpacing ? " " : "", concat$6(specifiers), options.bracketSpacing ? " " : "", "}"]); ++ } ++ } ++ ++ parts.push(decl.exportKind === "type" ? "type " : "", concat$6(defaultSpecifiers), concat$6([isDefaultFollowed ? ", " : ""]), concat$6(namespaceSpecifiers), concat$6([isNamespaceFollowed ? ", " : ""]), printed); ++ } else { ++ parts.push("{}"); ++ } ++ ++ if (decl.source) { ++ parts.push(" from ", path.call(print, "source")); ++ } ++ ++ parts.push(semi); ++ } ++ ++ return concat$6(parts); ++} ++ ++function printFlowDeclaration(path, parts) { ++ const parentExportDecl = getParentExportDeclaration$1(path); ++ ++ if (parentExportDecl) { ++ assert.strictEqual(parentExportDecl.type, "DeclareExportDeclaration"); ++ } else { ++ // If the parent node has type DeclareExportDeclaration, then it ++ // will be responsible for printing the "declare" token. Otherwise ++ // it needs to be printed with this non-exported declaration node. ++ parts.unshift("declare "); ++ } ++ ++ return concat$6(parts); ++} ++ ++function printTypeScriptModifiers(path, options, print) { ++ const n = path.getValue(); ++ ++ if (!n.modifiers || !n.modifiers.length) { ++ return ""; ++ } ++ ++ return concat$6([join$4(" ", path.map(print, "modifiers")), " "]); ++} ++ ++function printTypeParameters(path, options, print, paramsKey) { ++ const n = path.getValue(); ++ ++ if (!n[paramsKey]) { ++ return ""; ++ } // for TypeParameterDeclaration typeParameters is a single node ++ ++ ++ if (!Array.isArray(n[paramsKey])) { ++ return path.call(print, paramsKey); ++ } ++ ++ const grandparent = path.getNode(2); ++ const greatGrandParent = path.getNode(3); ++ const greatGreatGrandParent = path.getNode(4); ++ const isParameterInTestCall = grandparent != null && isTestCall$1(grandparent); ++ const shouldInline = isParameterInTestCall || n[paramsKey].length === 0 || n[paramsKey].length === 1 && (shouldHugType(n[paramsKey][0]) || n[paramsKey][0].type === "GenericTypeAnnotation" && shouldHugType(n[paramsKey][0].id) || n[paramsKey][0].type === "TSTypeReference" && shouldHugType(n[paramsKey][0].typeName) || n[paramsKey][0].type === "NullableTypeAnnotation" || // See https://github.com/prettier/prettier/pull/6467 for the context. ++ greatGreatGrandParent && greatGreatGrandParent.type === "VariableDeclarator" && grandparent.type === "TSTypeAnnotation" && greatGrandParent.type !== "ArrowFunctionExpression" && n[paramsKey][0].type !== "TSUnionType" && n[paramsKey][0].type !== "UnionTypeAnnotation" && n[paramsKey][0].type !== "TSIntersectionType" && n[paramsKey][0].type !== "IntersectionTypeAnnotation" && n[paramsKey][0].type !== "TSConditionalType" && n[paramsKey][0].type !== "TSMappedType" && n[paramsKey][0].type !== "TSTypeOperator" && n[paramsKey][0].type !== "TSIndexedAccessType" && n[paramsKey][0].type !== "TSArrayType"); ++ ++ function printDanglingCommentsForInline(n) { ++ if (!hasDanglingComments$1(n)) { ++ return ""; ++ } ++ ++ const hasOnlyBlockComments = n.comments.every(comments$1.isBlockComment); ++ const printed = comments.printDanglingComments(path, options, ++ /* sameIndent */ ++ hasOnlyBlockComments); ++ ++ if (hasOnlyBlockComments) { ++ return printed; ++ } ++ ++ return concat$6([printed, hardline$4]); ++ } ++ ++ if (shouldInline) { ++ return concat$6(["<", join$4(", ", path.map(print, paramsKey)), printDanglingCommentsForInline(n), ">"]); ++ } ++ ++ return group$2(concat$6(["<", indent$3(concat$6([softline$2, join$4(concat$6([",", line$4]), path.map(print, paramsKey))])), ifBreak$1(options.parser !== "typescript" && options.parser !== "babel-ts" && shouldPrintComma(options, "all") ? "," : ""), softline$2, ">"])); ++} ++ ++function printClass(path, options, print) { ++ const n = path.getValue(); ++ const parts = []; ++ ++ if (n.abstract) { ++ parts.push("abstract "); ++ } ++ ++ parts.push("class"); ++ ++ if (n.id) { ++ parts.push(" ", path.call(print, "id")); ++ } ++ ++ parts.push(path.call(print, "typeParameters")); ++ const partsGroup = []; ++ ++ if (n.superClass) { ++ const printed = concat$6(["extends ", path.call(print, "superClass"), path.call(print, "superTypeParameters")]); // Keep old behaviour of extends in same line ++ // If there is only on extends and there are not comments ++ ++ if ((!n.implements || n.implements.length === 0) && (!n.superClass.comments || n.superClass.comments.length === 0)) { ++ parts.push(concat$6([" ", path.call(superClass => comments.printComments(superClass, () => printed, options), "superClass")])); ++ } else { ++ partsGroup.push(group$2(concat$6([line$4, path.call(superClass => comments.printComments(superClass, () => printed, options), "superClass")]))); ++ } ++ } else if (n.extends && n.extends.length > 0) { ++ parts.push(" extends ", join$4(", ", path.map(print, "extends"))); ++ } ++ ++ if (n.mixins && n.mixins.length > 0) { ++ partsGroup.push(line$4, "mixins ", group$2(indent$3(join$4(concat$6([",", line$4]), path.map(print, "mixins"))))); ++ } ++ ++ if (n.implements && n.implements.length > 0) { ++ partsGroup.push(line$4, "implements", group$2(indent$3(concat$6([line$4, join$4(concat$6([",", line$4]), path.map(print, "implements"))])))); ++ } ++ ++ if (partsGroup.length > 0) { ++ parts.push(group$2(indent$3(concat$6(partsGroup)))); ++ } ++ ++ if (n.body && n.body.comments && hasLeadingOwnLineComment$1(options.originalText, n.body, options)) { ++ parts.push(hardline$4); ++ } else { ++ parts.push(" "); ++ } ++ ++ parts.push(path.call(print, "body")); ++ return parts; ++} ++ ++function printOptionalToken(path) { ++ const node = path.getValue(); ++ ++ if (!node.optional || // It's an optional computed method parsed by typescript-estree. ++ // "?" is printed in `printMethod`. ++ node.type === "Identifier" && node === path.getParentNode().key) { ++ return ""; ++ } ++ ++ if (node.type === "OptionalCallExpression" || node.type === "OptionalMemberExpression" && node.computed) { ++ return "?."; ++ } ++ ++ return "?"; ++} ++ ++function printMemberLookup(path, options, print) { ++ const property = path.call(print, "property"); ++ const n = path.getValue(); ++ const optional = printOptionalToken(path); ++ ++ if (!n.computed) { ++ return concat$6([optional, ".", property]); ++ } ++ ++ if (!n.property || isNumericLiteral$1(n.property)) { ++ return concat$6([optional, "[", property, "]"]); ++ } ++ ++ return group$2(concat$6([optional, "[", indent$3(concat$6([softline$2, property])), softline$2, "]"])); ++} ++ ++function printBindExpressionCallee(path, options, print) { ++ return concat$6(["::", path.call(print, "callee")]); ++} // We detect calls on member expressions specially to format a ++// common pattern better. The pattern we are looking for is this: ++// ++// arr ++// .map(x => x + 1) ++// .filter(x => x > 10) ++// .some(x => x % 2) ++// ++// The way it is structured in the AST is via a nested sequence of ++// MemberExpression and CallExpression. We need to traverse the AST ++// and make groups out of it to print it in the desired way. ++ ++ ++function printMemberChain(path, options, print) { ++ // The first phase is to linearize the AST by traversing it down. ++ // ++ // a().b() ++ // has the following AST structure: ++ // CallExpression(MemberExpression(CallExpression(Identifier))) ++ // and we transform it into ++ // [Identifier, CallExpression, MemberExpression, CallExpression] ++ const printedNodes = []; // Here we try to retain one typed empty line after each call expression or ++ // the first group whether it is in parentheses or not ++ ++ function shouldInsertEmptyLineAfter(node) { ++ const { ++ originalText ++ } = options; ++ const nextCharIndex = getNextNonSpaceNonCommentCharacterIndex$3(originalText, node, options.locEnd); ++ const nextChar = originalText.charAt(nextCharIndex); // if it is cut off by a parenthesis, we only account for one typed empty ++ // line after that parenthesis ++ ++ if (nextChar === ")") { ++ return isNextLineEmptyAfterIndex$2(originalText, nextCharIndex + 1, options.locEnd); ++ } ++ ++ return isNextLineEmpty$2(originalText, node, options.locEnd); ++ } ++ ++ function rec(path) { ++ const node = path.getValue(); ++ ++ if ((node.type === "CallExpression" || node.type === "OptionalCallExpression") && (isMemberish$1(node.callee) || node.callee.type === "CallExpression" || node.callee.type === "OptionalCallExpression")) { ++ printedNodes.unshift({ ++ node, ++ printed: concat$6([comments.printComments(path, () => concat$6([printOptionalToken(path), printFunctionTypeParameters(path, options, print), printArgumentsList(path, options, print)]), options), shouldInsertEmptyLineAfter(node) ? hardline$4 : ""]) ++ }); ++ path.call(callee => rec(callee), "callee"); ++ } else if (isMemberish$1(node)) { ++ printedNodes.unshift({ ++ node, ++ needsParens: needsParens_1(path, options), ++ printed: comments.printComments(path, () => node.type === "OptionalMemberExpression" || node.type === "MemberExpression" ? printMemberLookup(path, options, print) : printBindExpressionCallee(path, options, print), options) ++ }); ++ path.call(object => rec(object), "object"); ++ } else if (node.type === "TSNonNullExpression") { ++ printedNodes.unshift({ ++ node, ++ printed: comments.printComments(path, () => "!", options) ++ }); ++ path.call(expression => rec(expression), "expression"); ++ } else { ++ printedNodes.unshift({ ++ node, ++ printed: path.call(print) ++ }); ++ } ++ } // Note: the comments of the root node have already been printed, so we ++ // need to extract this first call without printing them as they would ++ // if handled inside of the recursive call. ++ ++ ++ const node = path.getValue(); ++ printedNodes.unshift({ ++ node, ++ printed: concat$6([printOptionalToken(path), printFunctionTypeParameters(path, options, print), printArgumentsList(path, options, print)]) ++ }); ++ path.call(callee => rec(callee), "callee"); // Once we have a linear list of printed nodes, we want to create groups out ++ // of it. ++ // ++ // a().b.c().d().e ++ // will be grouped as ++ // [ ++ // [Identifier, CallExpression], ++ // [MemberExpression, MemberExpression, CallExpression], ++ // [MemberExpression, CallExpression], ++ // [MemberExpression], ++ // ] ++ // so that we can print it as ++ // a() ++ // .b.c() ++ // .d() ++ // .e ++ // The first group is the first node followed by ++ // - as many CallExpression as possible ++ // < fn()()() >.something() ++ // - as many array accessors as possible ++ // < fn()[0][1][2] >.something() ++ // - then, as many MemberExpression as possible but the last one ++ // < this.items >.something() ++ ++ const groups = []; ++ let currentGroup = [printedNodes[0]]; ++ let i = 1; ++ ++ for (; i < printedNodes.length; ++i) { ++ if (printedNodes[i].node.type === "TSNonNullExpression" || printedNodes[i].node.type === "OptionalCallExpression" || printedNodes[i].node.type === "CallExpression" || (printedNodes[i].node.type === "MemberExpression" || printedNodes[i].node.type === "OptionalMemberExpression") && printedNodes[i].node.computed && isNumericLiteral$1(printedNodes[i].node.property)) { ++ currentGroup.push(printedNodes[i]); ++ } else { ++ break; ++ } ++ } ++ ++ if (printedNodes[0].node.type !== "CallExpression" && printedNodes[0].node.type !== "OptionalCallExpression") { ++ for (; i + 1 < printedNodes.length; ++i) { ++ if (isMemberish$1(printedNodes[i].node) && isMemberish$1(printedNodes[i + 1].node)) { ++ currentGroup.push(printedNodes[i]); ++ } else { ++ break; ++ } ++ } ++ } ++ ++ groups.push(currentGroup); ++ currentGroup = []; // Then, each following group is a sequence of MemberExpression followed by ++ // a sequence of CallExpression. To compute it, we keep adding things to the ++ // group until we has seen a CallExpression in the past and reach a ++ // MemberExpression ++ ++ let hasSeenCallExpression = false; ++ ++ for (; i < printedNodes.length; ++i) { ++ if (hasSeenCallExpression && isMemberish$1(printedNodes[i].node)) { ++ // [0] should be appended at the end of the group instead of the ++ // beginning of the next one ++ if (printedNodes[i].node.computed && isNumericLiteral$1(printedNodes[i].node.property)) { ++ currentGroup.push(printedNodes[i]); ++ continue; ++ } ++ ++ groups.push(currentGroup); ++ currentGroup = []; ++ hasSeenCallExpression = false; ++ } ++ ++ if (printedNodes[i].node.type === "CallExpression" || printedNodes[i].node.type === "OptionalCallExpression") { ++ hasSeenCallExpression = true; ++ } ++ ++ currentGroup.push(printedNodes[i]); ++ ++ if (printedNodes[i].node.comments && printedNodes[i].node.comments.some(comment => comment.trailing)) { ++ groups.push(currentGroup); ++ currentGroup = []; ++ hasSeenCallExpression = false; ++ } ++ } ++ ++ if (currentGroup.length > 0) { ++ groups.push(currentGroup); ++ } // There are cases like Object.keys(), Observable.of(), _.values() where ++ // they are the subject of all the chained calls and therefore should ++ // be kept on the same line: ++ // ++ // Object.keys(items) ++ // .filter(x => x) ++ // .map(x => x) ++ // ++ // In order to detect those cases, we use an heuristic: if the first ++ // node is an identifier with the name starting with a capital ++ // letter or just a sequence of _$. The rationale is that they are ++ // likely to be factories. ++ ++ ++ function isFactory(name) { ++ return /^[A-Z]|^[_$]+$/.test(name); ++ } // In case the Identifier is shorter than tab width, we can keep the ++ // first call in a single line, if it's an ExpressionStatement. ++ // ++ // d3.scaleLinear() ++ // .domain([0, 100]) ++ // .range([0, width]); ++ // ++ ++ ++ function isShort(name) { ++ return name.length <= options.tabWidth; ++ } ++ ++ function shouldNotWrap(groups) { ++ const parent = path.getParentNode(); ++ const isExpression = parent && parent.type === "ExpressionStatement"; ++ const hasComputed = groups[1].length && groups[1][0].node.computed; ++ ++ if (groups[0].length === 1) { ++ const firstNode = groups[0][0].node; ++ return firstNode.type === "ThisExpression" || firstNode.type === "Identifier" && (isFactory(firstNode.name) || isExpression && isShort(firstNode.name) || hasComputed); ++ } ++ ++ const lastNode = getLast$2(groups[0]).node; ++ return (lastNode.type === "MemberExpression" || lastNode.type === "OptionalMemberExpression") && lastNode.property.type === "Identifier" && (isFactory(lastNode.property.name) || hasComputed); ++ } ++ ++ const shouldMerge = groups.length >= 2 && !groups[1][0].node.comments && shouldNotWrap(groups); ++ ++ function printGroup(printedGroup) { ++ const printed = printedGroup.map(tuple => tuple.printed); // Checks if the last node (i.e. the parent node) needs parens and print ++ // accordingly ++ ++ if (printedGroup.length > 0 && printedGroup[printedGroup.length - 1].needsParens) { ++ return concat$6(["(", ...printed, ")"]); ++ } ++ ++ return concat$6(printed); ++ } ++ ++ function printIndentedGroup(groups) { ++ if (groups.length === 0) { ++ return ""; ++ } ++ ++ return indent$3(group$2(concat$6([hardline$4, join$4(hardline$4, groups.map(printGroup))]))); ++ } ++ ++ const printedGroups = groups.map(printGroup); ++ const oneLine = concat$6(printedGroups); ++ const cutoff = shouldMerge ? 3 : 2; ++ const flatGroups = groups.reduce((res, group) => res.concat(group), []); ++ const hasComment = flatGroups.slice(1, -1).some(node => hasLeadingComment$3(node.node)) || flatGroups.slice(0, -1).some(node => hasTrailingComment$1(node.node)) || groups[cutoff] && hasLeadingComment$3(groups[cutoff][0].node); // If we only have a single `.`, we shouldn't do anything fancy and just ++ // render everything concatenated together. ++ ++ if (groups.length <= cutoff && !hasComment) { ++ if (isLongCurriedCallExpression$1(path)) { ++ return oneLine; ++ } ++ ++ return group$2(oneLine); ++ } // Find out the last node in the first group and check if it has an ++ // empty line after ++ ++ ++ const lastNodeBeforeIndent = getLast$2(shouldMerge ? groups.slice(1, 2)[0] : groups[0]).node; ++ const shouldHaveEmptyLineBeforeIndent = lastNodeBeforeIndent.type !== "CallExpression" && lastNodeBeforeIndent.type !== "OptionalCallExpression" && shouldInsertEmptyLineAfter(lastNodeBeforeIndent); ++ const expanded = concat$6([printGroup(groups[0]), shouldMerge ? concat$6(groups.slice(1, 2).map(printGroup)) : "", shouldHaveEmptyLineBeforeIndent ? hardline$4 : "", printIndentedGroup(groups.slice(shouldMerge ? 2 : 1))]); ++ const callExpressions = printedNodes.map(({ ++ node ++ }) => node).filter(isCallOrOptionalCallExpression$1); // We don't want to print in one line if the chain has: ++ // * A comment. ++ // * Non-trivial arguments. ++ // * Any group but the last one has a hard line. ++ // If the last group is a function it's okay to inline if it fits. ++ ++ if (hasComment || callExpressions.length > 2 && callExpressions.some(expr => !expr.arguments.every(arg => isSimpleCallArgument$1(arg, 0))) || printedGroups.slice(0, -1).some(willBreak$1) || ++ /** ++ * scopes.filter(scope => scope.value !== '').map((scope, i) => { ++ * // multi line content ++ * }) ++ */ ++ ((lastGroupDoc, lastGroupNode) => isCallOrOptionalCallExpression$1(lastGroupNode) && willBreak$1(lastGroupDoc))(getLast$2(printedGroups), getLast$2(getLast$2(groups)).node) && callExpressions.slice(0, -1).some(n => n.arguments.some(isFunctionOrArrowExpression$1))) { ++ return group$2(expanded); ++ } ++ ++ return concat$6([// We only need to check `oneLine` because if `expanded` is chosen ++ // that means that the parent group has already been broken ++ // naturally ++ willBreak$1(oneLine) || shouldHaveEmptyLineBeforeIndent ? breakParent$2 : "", conditionalGroup$1([oneLine, expanded])]); ++} ++ ++function separatorNoWhitespace(isFacebookTranslationTag, child, childNode, nextNode) { ++ if (isFacebookTranslationTag) { ++ return ""; ++ } ++ ++ if (childNode.type === "JSXElement" && !childNode.closingElement || nextNode && nextNode.type === "JSXElement" && !nextNode.closingElement) { ++ return child.length === 1 ? softline$2 : hardline$4; ++ } ++ ++ return softline$2; ++} ++ ++function separatorWithWhitespace(isFacebookTranslationTag, child, childNode, nextNode) { ++ if (isFacebookTranslationTag) { ++ return hardline$4; ++ } ++ ++ if (child.length === 1) { ++ return childNode.type === "JSXElement" && !childNode.closingElement || nextNode && nextNode.type === "JSXElement" && !nextNode.closingElement ? hardline$4 : softline$2; ++ } ++ ++ return hardline$4; ++} // JSX Children are strange, mostly for two reasons: ++// 1. JSX reads newlines into string values, instead of skipping them like JS ++// 2. up to one whitespace between elements within a line is significant, ++// but not between lines. ++// ++// Leading, trailing, and lone whitespace all need to ++// turn themselves into the rather ugly `{' '}` when breaking. ++// ++// We print JSX using the `fill` doc primitive. ++// This requires that we give it an array of alternating ++// content and whitespace elements. ++// To ensure this we add dummy `""` content elements as needed. ++ ++ ++function printJSXChildren(path, options, print, jsxWhitespace, isFacebookTranslationTag) { ++ const n = path.getValue(); ++ const children = []; // using `map` instead of `each` because it provides `i` ++ ++ path.map((childPath, i) => { ++ const child = childPath.getValue(); ++ ++ if (isLiteral$1(child)) { ++ const text = rawText$1(child); // Contains a non-whitespace character ++ ++ if (isMeaningfulJSXText$1(child)) { ++ const words = text.split(matchJsxWhitespaceRegex$1); // Starts with whitespace ++ ++ if (words[0] === "") { ++ children.push(""); ++ words.shift(); ++ ++ if (/\n/.test(words[0])) { ++ const next = n.children[i + 1]; ++ children.push(separatorWithWhitespace(isFacebookTranslationTag, words[1], child, next)); ++ } else { ++ children.push(jsxWhitespace); ++ } ++ ++ words.shift(); ++ } ++ ++ let endWhitespace; // Ends with whitespace ++ ++ if (getLast$2(words) === "") { ++ words.pop(); ++ endWhitespace = words.pop(); ++ } // This was whitespace only without a new line. ++ ++ ++ if (words.length === 0) { ++ return; ++ } ++ ++ words.forEach((word, i) => { ++ if (i % 2 === 1) { ++ children.push(line$4); ++ } else { ++ children.push(word); ++ } ++ }); ++ ++ if (endWhitespace !== undefined) { ++ if (/\n/.test(endWhitespace)) { ++ const next = n.children[i + 1]; ++ children.push(separatorWithWhitespace(isFacebookTranslationTag, getLast$2(children), child, next)); ++ } else { ++ children.push(jsxWhitespace); ++ } ++ } else { ++ const next = n.children[i + 1]; ++ children.push(separatorNoWhitespace(isFacebookTranslationTag, getLast$2(children), child, next)); ++ } ++ } else if (/\n/.test(text)) { ++ // Keep (up to one) blank line between tags/expressions/text. ++ // Note: We don't keep blank lines between text elements. ++ if (text.match(/\n/g).length > 1) { ++ children.push(""); ++ children.push(hardline$4); ++ } ++ } else { ++ children.push(""); ++ children.push(jsxWhitespace); ++ } ++ } else { ++ const printedChild = print(childPath); ++ children.push(printedChild); ++ const next = n.children[i + 1]; ++ const directlyFollowedByMeaningfulText = next && isMeaningfulJSXText$1(next); ++ ++ if (directlyFollowedByMeaningfulText) { ++ const firstWord = rawText$1(next).trim().split(matchJsxWhitespaceRegex$1)[0]; ++ children.push(separatorNoWhitespace(isFacebookTranslationTag, firstWord, child, next)); ++ } else { ++ children.push(hardline$4); ++ } ++ } ++ }, "children"); ++ return children; ++} // JSX expands children from the inside-out, instead of the outside-in. ++// This is both to break children before attributes, ++// and to ensure that when children break, their parents do as well. ++// ++// Any element that is written without any newlines and fits on a single line ++// is left that way. ++// Not only that, any user-written-line containing multiple JSX siblings ++// should also be kept on one line if possible, ++// so each user-written-line is wrapped in its own group. ++// ++// Elements that contain newlines or don't fit on a single line (recursively) ++// are fully-split, using hardline and shouldBreak: true. ++// ++// To support that case properly, all leading and trailing spaces ++// are stripped from the list of children, and replaced with a single hardline. ++ ++ ++function printJSXElement(path, options, print) { ++ const n = path.getValue(); ++ ++ if (n.type === "JSXElement" && isEmptyJSXElement$1(n)) { ++ return concat$6([path.call(print, "openingElement"), path.call(print, "closingElement")]); ++ } ++ ++ const openingLines = n.type === "JSXElement" ? path.call(print, "openingElement") : path.call(print, "openingFragment"); ++ const closingLines = n.type === "JSXElement" ? path.call(print, "closingElement") : path.call(print, "closingFragment"); ++ ++ if (n.children.length === 1 && n.children[0].type === "JSXExpressionContainer" && (n.children[0].expression.type === "TemplateLiteral" || n.children[0].expression.type === "TaggedTemplateExpression")) { ++ return concat$6([openingLines, concat$6(path.map(print, "children")), closingLines]); ++ } // Convert `{" "}` to text nodes containing a space. ++ // This makes it easy to turn them into `jsxWhitespace` which ++ // can then print as either a space or `{" "}` when breaking. ++ ++ ++ n.children = n.children.map(child => { ++ if (isJSXWhitespaceExpression$1(child)) { ++ return { ++ type: "JSXText", ++ value: " ", ++ raw: " " ++ }; ++ } ++ ++ return child; ++ }); ++ const containsTag = n.children.filter(isJSXNode$1).length > 0; ++ const containsMultipleExpressions = n.children.filter(child => child.type === "JSXExpressionContainer").length > 1; ++ const containsMultipleAttributes = n.type === "JSXElement" && n.openingElement.attributes.length > 1; // Record any breaks. Should never go from true to false, only false to true. ++ ++ let forcedBreak = willBreak$1(openingLines) || containsTag || containsMultipleAttributes || containsMultipleExpressions; ++ const isMdxBlock = path.getParentNode().rootMarker === "mdx"; ++ const rawJsxWhitespace = options.singleQuote ? "{' '}" : '{" "}'; ++ const jsxWhitespace = isMdxBlock ? concat$6([" "]) : ifBreak$1(concat$6([rawJsxWhitespace, softline$2]), " "); ++ const isFacebookTranslationTag = n.openingElement && n.openingElement.name && n.openingElement.name.name === "fbt"; ++ const children = printJSXChildren(path, options, print, jsxWhitespace, isFacebookTranslationTag); ++ const containsText = n.children.some(child => isMeaningfulJSXText$1(child)); // We can end up we multiple whitespace elements with empty string ++ // content between them. ++ // We need to remove empty whitespace and softlines before JSX whitespace ++ // to get the correct output. ++ ++ for (let i = children.length - 2; i >= 0; i--) { ++ const isPairOfEmptyStrings = children[i] === "" && children[i + 1] === ""; ++ const isPairOfHardlines = children[i] === hardline$4 && children[i + 1] === "" && children[i + 2] === hardline$4; ++ const isLineFollowedByJSXWhitespace = (children[i] === softline$2 || children[i] === hardline$4) && children[i + 1] === "" && children[i + 2] === jsxWhitespace; ++ const isJSXWhitespaceFollowedByLine = children[i] === jsxWhitespace && children[i + 1] === "" && (children[i + 2] === softline$2 || children[i + 2] === hardline$4); ++ const isDoubleJSXWhitespace = children[i] === jsxWhitespace && children[i + 1] === "" && children[i + 2] === jsxWhitespace; ++ const isPairOfHardOrSoftLines = children[i] === softline$2 && children[i + 1] === "" && children[i + 2] === hardline$4 || children[i] === hardline$4 && children[i + 1] === "" && children[i + 2] === softline$2; ++ ++ if (isPairOfHardlines && containsText || isPairOfEmptyStrings || isLineFollowedByJSXWhitespace || isDoubleJSXWhitespace || isPairOfHardOrSoftLines) { ++ children.splice(i, 2); ++ } else if (isJSXWhitespaceFollowedByLine) { ++ children.splice(i + 1, 2); ++ } ++ } // Trim trailing lines (or empty strings) ++ ++ ++ while (children.length && (isLineNext$1(getLast$2(children)) || isEmpty$1(getLast$2(children)))) { ++ children.pop(); ++ } // Trim leading lines (or empty strings) ++ ++ ++ while (children.length && (isLineNext$1(children[0]) || isEmpty$1(children[0])) && (isLineNext$1(children[1]) || isEmpty$1(children[1]))) { ++ children.shift(); ++ children.shift(); ++ } // Tweak how we format children if outputting this element over multiple lines. ++ // Also detect whether we will force this element to output over multiple lines. ++ ++ ++ const multilineChildren = []; ++ children.forEach((child, i) => { ++ // There are a number of situations where we need to ensure we display ++ // whitespace as `{" "}` when outputting this element over multiple lines. ++ if (child === jsxWhitespace) { ++ if (i === 1 && children[i - 1] === "") { ++ if (children.length === 2) { ++ // Solitary whitespace ++ multilineChildren.push(rawJsxWhitespace); ++ return; ++ } // Leading whitespace ++ ++ ++ multilineChildren.push(concat$6([rawJsxWhitespace, hardline$4])); ++ return; ++ } else if (i === children.length - 1) { ++ // Trailing whitespace ++ multilineChildren.push(rawJsxWhitespace); ++ return; ++ } else if (children[i - 1] === "" && children[i - 2] === hardline$4) { ++ // Whitespace after line break ++ multilineChildren.push(rawJsxWhitespace); ++ return; ++ } ++ } ++ ++ multilineChildren.push(child); ++ ++ if (willBreak$1(child)) { ++ forcedBreak = true; ++ } ++ }); // If there is text we use `fill` to fit as much onto each line as possible. ++ // When there is no text (just tags and expressions) we use `group` ++ // to output each on a separate line. ++ ++ const content = containsText ? fill$3(multilineChildren) : group$2(concat$6(multilineChildren), { ++ shouldBreak: true ++ }); ++ ++ if (isMdxBlock) { ++ return content; ++ } ++ ++ const multiLineElem = group$2(concat$6([openingLines, indent$3(concat$6([hardline$4, content])), hardline$4, closingLines])); ++ ++ if (forcedBreak) { ++ return multiLineElem; ++ } ++ ++ return conditionalGroup$1([group$2(concat$6([openingLines, concat$6(children), closingLines])), multiLineElem]); ++} ++ ++function maybeWrapJSXElementInParens(path, elem, options) { ++ const parent = path.getParentNode(); ++ ++ if (!parent) { ++ return elem; ++ } ++ ++ const NO_WRAP_PARENTS = { ++ ArrayExpression: true, ++ JSXAttribute: true, ++ JSXElement: true, ++ JSXExpressionContainer: true, ++ JSXFragment: true, ++ ExpressionStatement: true, ++ CallExpression: true, ++ OptionalCallExpression: true, ++ ConditionalExpression: true, ++ JsExpressionRoot: true ++ }; ++ ++ if (NO_WRAP_PARENTS[parent.type]) { ++ return elem; ++ } ++ ++ const shouldBreak = path.match(undefined, node => node.type === "ArrowFunctionExpression", isCallOrOptionalCallExpression$1, node => node.type === "JSXExpressionContainer"); ++ const needsParens = needsParens_1(path, options); ++ return group$2(concat$6([needsParens ? "" : ifBreak$1("("), indent$3(concat$6([softline$2, elem])), softline$2, needsParens ? "" : ifBreak$1(")")]), { ++ shouldBreak ++ }); ++} ++ ++function shouldInlineLogicalExpression(node) { ++ if (node.type !== "LogicalExpression") { ++ return false; ++ } ++ ++ if (node.right.type === "ObjectExpression" && node.right.properties.length !== 0) { ++ return true; ++ } ++ ++ if (node.right.type === "ArrayExpression" && node.right.elements.length !== 0) { ++ return true; ++ } ++ ++ if (isJSXNode$1(node.right)) { ++ return true; ++ } ++ ++ return false; ++} // For binary expressions to be consistent, we need to group ++// subsequent operators with the same precedence level under a single ++// group. Otherwise they will be nested such that some of them break ++// onto new lines but not all. Operators with the same precedence ++// level should either all break or not. Because we group them by ++// precedence level and the AST is structured based on precedence ++// level, things are naturally broken up correctly, i.e. `&&` is ++// broken before `+`. ++ ++ ++function printBinaryishExpressions(path, print, options, isNested, isInsideParenthesis) { ++ let parts = []; ++ const node = path.getValue(); // We treat BinaryExpression and LogicalExpression nodes the same. ++ ++ if (isBinaryish$1(node)) { ++ // Put all operators with the same precedence level in the same ++ // group. The reason we only need to do this with the `left` ++ // expression is because given an expression like `1 + 2 - 3`, it ++ // is always parsed like `((1 + 2) - 3)`, meaning the `left` side ++ // is where the rest of the expression will exist. Binary ++ // expressions on the right side mean they have a difference ++ // precedence level and should be treated as a separate group, so ++ // print them normally. (This doesn't hold for the `**` operator, ++ // which is unique in that it is right-associative.) ++ if (shouldFlatten$1(node.operator, node.left.operator)) { ++ // Flatten them out by recursively calling this function. ++ parts = parts.concat(path.call(left => printBinaryishExpressions(left, print, options, ++ /* isNested */ ++ true, isInsideParenthesis), "left")); ++ } else { ++ parts.push(path.call(print, "left")); ++ } ++ ++ const shouldInline = shouldInlineLogicalExpression(node); ++ const lineBeforeOperator = (node.operator === "|>" || node.type === "NGPipeExpression" || node.operator === "|" && options.parser === "__vue_expression") && !hasLeadingOwnLineComment$1(options.originalText, node.right, options); ++ const operator = node.type === "NGPipeExpression" ? "|" : node.operator; ++ const rightSuffix = node.type === "NGPipeExpression" && node.arguments.length !== 0 ? group$2(indent$3(concat$6([softline$2, ": ", join$4(concat$6([softline$2, ":", ifBreak$1(" ")]), path.map(print, "arguments").map(arg => align$1(2, group$2(arg))))]))) : ""; ++ const right = shouldInline ? concat$6([operator, " ", path.call(print, "right"), rightSuffix]) : concat$6([lineBeforeOperator ? softline$2 : "", operator, lineBeforeOperator ? " " : line$4, path.call(print, "right"), rightSuffix]); // If there's only a single binary expression, we want to create a group ++ // in order to avoid having a small right part like -1 be on its own line. ++ ++ const parent = path.getParentNode(); ++ const shouldGroup = !(isInsideParenthesis && node.type === "LogicalExpression") && parent.type !== node.type && node.left.type !== node.type && node.right.type !== node.type; ++ parts.push(" ", shouldGroup ? group$2(right) : right); // The root comments are already printed, but we need to manually print ++ // the other ones since we don't call the normal print on BinaryExpression, ++ // only for the left and right parts ++ ++ if (isNested && node.comments) { ++ parts = comments.printComments(path, () => concat$6(parts), options); ++ } ++ } else { ++ // Our stopping case. Simply print the node normally. ++ parts.push(path.call(print)); ++ } ++ ++ return parts; ++} ++ ++function printAssignmentRight(leftNode, rightNode, printedRight, options) { ++ if (hasLeadingOwnLineComment$1(options.originalText, rightNode, options)) { ++ return indent$3(concat$6([line$4, printedRight])); ++ } ++ ++ const canBreak = isBinaryish$1(rightNode) && !shouldInlineLogicalExpression(rightNode) || rightNode.type === "ConditionalExpression" && isBinaryish$1(rightNode.test) && !shouldInlineLogicalExpression(rightNode.test) || rightNode.type === "StringLiteralTypeAnnotation" || rightNode.type === "ClassExpression" && rightNode.decorators && rightNode.decorators.length || (leftNode.type === "Identifier" || isStringLiteral$1(leftNode) || leftNode.type === "MemberExpression") && (isStringLiteral$1(rightNode) || isMemberExpressionChain$1(rightNode)) && // do not put values on a separate line from the key in json ++ options.parser !== "json" && options.parser !== "json5" || rightNode.type === "SequenceExpression"; ++ ++ if (canBreak) { ++ return group$2(indent$3(concat$6([line$4, printedRight]))); ++ } ++ ++ return concat$6([" ", printedRight]); ++} ++ ++function printAssignment(leftNode, printedLeft, operator, rightNode, printedRight, options) { ++ if (!rightNode) { ++ return printedLeft; ++ } ++ ++ const printed = printAssignmentRight(leftNode, rightNode, printedRight, options); ++ return group$2(concat$6([printedLeft, operator, printed])); ++} ++ ++function adjustClause(node, clause, forceSpace) { ++ if (node.type === "EmptyStatement") { ++ return ";"; ++ } ++ ++ if (node.type === "BlockStatement" || forceSpace) { ++ return concat$6([" ", clause]); ++ } ++ ++ return indent$3(concat$6([line$4, clause])); ++} ++ ++function nodeStr(node, options, isFlowOrTypeScriptDirectiveLiteral) { ++ const raw = rawText$1(node); ++ const isDirectiveLiteral = isFlowOrTypeScriptDirectiveLiteral || node.type === "DirectiveLiteral"; ++ return printString$1(raw, options, isDirectiveLiteral); ++} ++ ++function printRegex(node) { ++ const flags = node.flags.split("").sort().join(""); ++ return `/${node.pattern}/${flags}`; ++} ++ ++function exprNeedsASIProtection(path, options) { ++ const node = path.getValue(); ++ const maybeASIProblem = needsParens_1(path, options) || node.type === "ParenthesizedExpression" || node.type === "TypeCastExpression" || node.type === "ArrowFunctionExpression" && !shouldPrintParamsWithoutParens(path, options) || node.type === "ArrayExpression" || node.type === "ArrayPattern" || node.type === "UnaryExpression" && node.prefix && (node.operator === "+" || node.operator === "-") || node.type === "TemplateLiteral" || node.type === "TemplateElement" || isJSXNode$1(node) || node.type === "BindExpression" && !node.object || node.type === "RegExpLiteral" || node.type === "Literal" && node.pattern || node.type === "Literal" && node.regex; ++ ++ if (maybeASIProblem) { ++ return true; ++ } ++ ++ if (!hasNakedLeftSide$2(node)) { ++ return false; ++ } ++ ++ return path.call(childPath => exprNeedsASIProtection(childPath, options), ...getLeftSidePathName$2(path, node)); ++} ++ ++function stmtNeedsASIProtection(path, options) { ++ const node = path.getNode(); ++ ++ if (node.type !== "ExpressionStatement") { ++ return false; ++ } ++ ++ return path.call(childPath => exprNeedsASIProtection(childPath, options), "expression"); ++} ++ ++function shouldHugType(node) { ++ if (isSimpleFlowType$1(node) || isObjectType$1(node)) { ++ return true; ++ } ++ ++ if (node.type === "UnionTypeAnnotation" || node.type === "TSUnionType") { ++ const voidCount = node.types.filter(n => n.type === "VoidTypeAnnotation" || n.type === "TSVoidKeyword" || n.type === "NullLiteralTypeAnnotation" || n.type === "TSNullKeyword").length; ++ const hasObject = node.types.some(n => n.type === "ObjectTypeAnnotation" || n.type === "TSTypeLiteral" || // This is a bit aggressive but captures Array<{x}> ++ n.type === "GenericTypeAnnotation" || n.type === "TSTypeReference"); ++ ++ if (node.types.length - 1 === voidCount && hasObject) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++ ++function shouldHugArguments(fun) { ++ if (!fun || fun.rest) { ++ return false; ++ } ++ ++ const params = fun.params || fun.parameters; ++ ++ if (!params || params.length !== 1) { ++ return false; ++ } ++ ++ const param = params[0]; ++ return !param.comments && (param.type === "ObjectPattern" || param.type === "ArrayPattern" || param.type === "Identifier" && param.typeAnnotation && (param.typeAnnotation.type === "TypeAnnotation" || param.typeAnnotation.type === "TSTypeAnnotation") && isObjectType$1(param.typeAnnotation.typeAnnotation) || param.type === "FunctionTypeParam" && isObjectType$1(param.typeAnnotation) || param.type === "AssignmentPattern" && (param.left.type === "ObjectPattern" || param.left.type === "ArrayPattern") && (param.right.type === "Identifier" || param.right.type === "ObjectExpression" && param.right.properties.length === 0 || param.right.type === "ArrayExpression" && param.right.elements.length === 0)); ++} ++ ++function printArrayItems(path, options, printPath, print) { ++ const printedElements = []; ++ let separatorParts = []; ++ path.each(childPath => { ++ printedElements.push(concat$6(separatorParts)); ++ printedElements.push(group$2(print(childPath))); ++ separatorParts = [",", line$4]; ++ ++ if (childPath.getValue() && isNextLineEmpty$2(options.originalText, childPath.getValue(), options.locEnd)) { ++ separatorParts.push(softline$2); ++ } ++ }, printPath); ++ return concat$6(printedElements); ++} ++ ++function printReturnAndThrowArgument(path, options, print) { ++ const node = path.getValue(); ++ const semi = options.semi ? ";" : ""; ++ const parts = []; ++ ++ if (node.argument) { ++ if (returnArgumentHasLeadingComment$1(options, node.argument)) { ++ parts.push(concat$6([" (", indent$3(concat$6([hardline$4, path.call(print, "argument")])), hardline$4, ")"])); ++ } else if (node.argument.type === "LogicalExpression" || node.argument.type === "BinaryExpression" || node.argument.type === "SequenceExpression") { ++ parts.push(group$2(concat$6([ifBreak$1(" (", " "), indent$3(concat$6([softline$2, path.call(print, "argument")])), softline$2, ifBreak$1(")")]))); ++ } else { ++ parts.push(" ", path.call(print, "argument")); ++ } ++ } ++ ++ const lastComment = Array.isArray(node.comments) && node.comments[node.comments.length - 1]; ++ const isLastCommentLine = lastComment && (lastComment.type === "CommentLine" || lastComment.type === "Line"); ++ ++ if (isLastCommentLine) { ++ parts.push(semi); ++ } ++ ++ if (hasDanglingComments$1(node)) { ++ parts.push(" ", comments.printDanglingComments(path, options, ++ /* sameIndent */ ++ true)); ++ } ++ ++ if (!isLastCommentLine) { ++ parts.push(semi); ++ } ++ ++ return concat$6(parts); ++} ++ ++function willPrintOwnComments(path ++/*, options */ ++) { ++ const node = path.getValue(); ++ const parent = path.getParentNode(); ++ return (node && (isJSXNode$1(node) || hasFlowShorthandAnnotationComment$2(node) || parent && (parent.type === "CallExpression" || parent.type === "OptionalCallExpression") && (hasFlowAnnotationComment$1(node.leadingComments) || hasFlowAnnotationComment$1(node.trailingComments))) || parent && (parent.type === "JSXSpreadAttribute" || parent.type === "JSXSpreadChild" || parent.type === "UnionTypeAnnotation" || parent.type === "TSUnionType" || (parent.type === "ClassDeclaration" || parent.type === "ClassExpression") && parent.superClass === node)) && (!hasIgnoreComment$2(path) || parent.type === "UnionTypeAnnotation" || parent.type === "TSUnionType"); ++} ++ ++function canAttachComment(node) { ++ return node.type && node.type !== "CommentBlock" && node.type !== "CommentLine" && node.type !== "Line" && node.type !== "Block" && node.type !== "EmptyStatement" && node.type !== "TemplateElement" && node.type !== "Import"; ++} ++ ++function printComment$1(commentPath, options) { ++ const comment = commentPath.getValue(); ++ ++ switch (comment.type) { ++ case "CommentBlock": ++ case "Block": ++ { ++ if (isIndentableBlockComment(comment)) { ++ const printed = printIndentableBlockComment(comment); // We need to prevent an edge case of a previous trailing comment ++ // printed as a `lineSuffix` which causes the comments to be ++ // interleaved. See https://github.com/prettier/prettier/issues/4412 ++ ++ if (comment.trailing && !hasNewline$4(options.originalText, options.locStart(comment), { ++ backwards: true ++ })) { ++ return concat$6([hardline$4, printed]); ++ } ++ ++ return printed; ++ } ++ ++ const commentEnd = options.locEnd(comment); ++ const isInsideFlowComment = options.originalText.slice(commentEnd - 3, commentEnd) === "*-/"; ++ return "/*" + comment.value + (isInsideFlowComment ? "*-/" : "*/"); ++ } ++ ++ case "CommentLine": ++ case "Line": ++ // Print shebangs with the proper comment characters ++ if (options.originalText.slice(options.locStart(comment)).startsWith("#!")) { ++ return "#!" + comment.value.trimEnd(); ++ } ++ ++ return "//" + comment.value.trimEnd(); ++ ++ default: ++ throw new Error("Not a comment: " + JSON.stringify(comment)); ++ } ++} ++ ++function isIndentableBlockComment(comment) { ++ // If the comment has multiple lines and every line starts with a star ++ // we can fix the indentation of each line. The stars in the `/*` and ++ // `*/` delimiters are not included in the comment value, so add them ++ // back first. ++ const lines = `*${comment.value}*`.split("\n"); ++ return lines.length > 1 && lines.every(line => line.trim()[0] === "*"); ++} ++ ++function printIndentableBlockComment(comment) { ++ const lines = comment.value.split("\n"); ++ return concat$6(["/*", join$4(hardline$4, lines.map((line, index) => index === 0 ? line.trimEnd() : " " + (index < lines.length - 1 ? line.trim() : line.trimStart()))), "*/"]); ++} ++ ++var printerEstree = { ++ preprocess: preprocess_1, ++ print: genericPrint, ++ embed: embed_1, ++ insertPragma: insertPragma$1, ++ massageAstNode: clean_1, ++ hasPrettierIgnore: hasPrettierIgnore$1, ++ willPrintOwnComments, ++ canAttachComment, ++ printComment: printComment$1, ++ isBlockComment: comments$1.isBlockComment, ++ handleComments: { ++ ownLine: comments$1.handleOwnLineComment, ++ endOfLine: comments$1.handleEndOfLineComment, ++ remaining: comments$1.handleRemainingComment ++ }, ++ getGapRegex: comments$1.getGapRegex, ++ getCommentChildNodes: comments$1.getCommentChildNodes ++}; ++ ++const { ++ concat: concat$7, ++ hardline: hardline$5, ++ indent: indent$4, ++ join: join$5 ++} = document.builders; ++ ++function genericPrint$1(path, options, print) { ++ const node = path.getValue(); ++ ++ switch (node.type) { ++ case "JsonRoot": ++ return concat$7([path.call(print, "node"), hardline$5]); ++ ++ case "ArrayExpression": ++ return node.elements.length === 0 ? "[]" : concat$7(["[", indent$4(concat$7([hardline$5, join$5(concat$7([",", hardline$5]), path.map(print, "elements"))])), hardline$5, "]"]); ++ ++ case "ObjectExpression": ++ return node.properties.length === 0 ? "{}" : concat$7(["{", indent$4(concat$7([hardline$5, join$5(concat$7([",", hardline$5]), path.map(print, "properties"))])), hardline$5, "}"]); ++ ++ case "ObjectProperty": ++ return concat$7([path.call(print, "key"), ": ", path.call(print, "value")]); ++ ++ case "UnaryExpression": ++ return concat$7([node.operator === "+" ? "" : node.operator, path.call(print, "argument")]); ++ ++ case "NullLiteral": ++ return "null"; ++ ++ case "BooleanLiteral": ++ return node.value ? "true" : "false"; ++ ++ case "StringLiteral": ++ case "NumericLiteral": ++ return JSON.stringify(node.value); ++ ++ case "Identifier": ++ return JSON.stringify(node.name); ++ ++ default: ++ /* istanbul ignore next */ ++ throw new Error("unknown type: " + JSON.stringify(node.type)); ++ } ++} ++ ++function clean$1(node, newNode ++/*, parent*/ ++) { ++ delete newNode.start; ++ delete newNode.end; ++ delete newNode.extra; ++ delete newNode.loc; ++ delete newNode.comments; ++ delete newNode.errors; ++ ++ if (node.type === "Identifier") { ++ return { ++ type: "StringLiteral", ++ value: node.name ++ }; ++ } ++ ++ if (node.type === "UnaryExpression" && node.operator === "+") { ++ return newNode.argument; ++ } ++} ++ ++var printerEstreeJson = { ++ preprocess: preprocess_1, ++ print: genericPrint$1, ++ massageAstNode: clean$1 ++}; ++ ++const CATEGORY_COMMON = "Common"; // format based on https://github.com/prettier/prettier/blob/master/src/main/core-options.js ++ ++var commonOptions = { ++ bracketSpacing: { ++ since: "0.0.0", ++ category: CATEGORY_COMMON, ++ type: "boolean", ++ default: true, ++ description: "Print spaces between brackets.", ++ oppositeDescription: "Do not print spaces between brackets." ++ }, ++ singleQuote: { ++ since: "0.0.0", ++ category: CATEGORY_COMMON, ++ type: "boolean", ++ default: false, ++ description: "Use single quotes instead of double quotes." ++ }, ++ proseWrap: { ++ since: "1.8.2", ++ category: CATEGORY_COMMON, ++ type: "choice", ++ default: [{ ++ since: "1.8.2", ++ value: true ++ }, { ++ since: "1.9.0", ++ value: "preserve" ++ }], ++ description: "How to wrap prose.", ++ choices: [{ ++ since: "1.9.0", ++ value: "always", ++ description: "Wrap prose if it exceeds the print width." ++ }, { ++ since: "1.9.0", ++ value: "never", ++ description: "Do not wrap prose." ++ }, { ++ since: "1.9.0", ++ value: "preserve", ++ description: "Wrap prose as-is." ++ }] ++ } ++}; ++ ++const CATEGORY_JAVASCRIPT = "JavaScript"; // format based on https://github.com/prettier/prettier/blob/master/src/main/core-options.js ++ ++var options$2 = { ++ arrowParens: { ++ since: "1.9.0", ++ category: CATEGORY_JAVASCRIPT, ++ type: "choice", ++ default: [{ ++ since: "1.9.0", ++ value: "avoid" ++ }, { ++ since: "2.0.0", ++ value: "always" ++ }], ++ description: "Include parentheses around a sole arrow function parameter.", ++ choices: [{ ++ value: "always", ++ description: "Always include parens. Example: `(x) => x`" ++ }, { ++ value: "avoid", ++ description: "Omit parens when possible. Example: `x => x`" ++ }] ++ }, ++ bracketSpacing: commonOptions.bracketSpacing, ++ jsxBracketSameLine: { ++ since: "0.17.0", ++ category: CATEGORY_JAVASCRIPT, ++ type: "boolean", ++ default: false, ++ description: "Put > on the last line instead of at a new line." ++ }, ++ semi: { ++ since: "1.0.0", ++ category: CATEGORY_JAVASCRIPT, ++ type: "boolean", ++ default: true, ++ description: "Print semicolons.", ++ oppositeDescription: "Do not print semicolons, except at the beginning of lines which may need them." ++ }, ++ singleQuote: commonOptions.singleQuote, ++ jsxSingleQuote: { ++ since: "1.15.0", ++ category: CATEGORY_JAVASCRIPT, ++ type: "boolean", ++ default: false, ++ description: "Use single quotes in JSX." ++ }, ++ quoteProps: { ++ since: "1.17.0", ++ category: CATEGORY_JAVASCRIPT, ++ type: "choice", ++ default: "as-needed", ++ description: "Change when properties in objects are quoted.", ++ choices: [{ ++ value: "as-needed", ++ description: "Only add quotes around object properties where required." ++ }, { ++ value: "consistent", ++ description: "If at least one property in an object requires quotes, quote all properties." ++ }, { ++ value: "preserve", ++ description: "Respect the input use of quotes in object properties." ++ }] ++ }, ++ trailingComma: { ++ since: "0.0.0", ++ category: CATEGORY_JAVASCRIPT, ++ type: "choice", ++ default: [{ ++ since: "0.0.0", ++ value: false ++ }, { ++ since: "0.19.0", ++ value: "none" ++ }, { ++ since: "2.0.0", ++ value: "es5" ++ }], ++ description: "Print trailing commas wherever possible when multi-line.", ++ choices: [{ ++ value: "es5", ++ description: "Trailing commas where valid in ES5 (objects, arrays, etc.)" ++ }, { ++ value: "none", ++ description: "No trailing commas." ++ }, { ++ value: "all", ++ description: "Trailing commas wherever possible (including function arguments)." ++ }] ++ } ++}; ++ ++var createLanguage = function (linguistData, override) { ++ const { ++ languageId ++ } = linguistData, ++ rest = _objectWithoutPropertiesLoose(linguistData, ["languageId"]); ++ ++ return Object.assign({ ++ linguistLanguageId: languageId ++ }, rest, {}, override(linguistData)); ++}; ++ ++var name$2 = "JavaScript"; ++var type = "programming"; ++var tmScope = "source.js"; ++var aceMode = "javascript"; ++var codemirrorMode = "javascript"; ++var codemirrorMimeType = "text/javascript"; ++var color = "#f1e05a"; ++var aliases = [ ++ "js", ++ "node" ++]; ++var extensions = [ ++ ".js", ++ "._js", ++ ".bones", ++ ".cjs", ++ ".es", ++ ".es6", ++ ".frag", ++ ".gs", ++ ".jake", ++ ".jsb", ++ ".jscad", ++ ".jsfl", ++ ".jsm", ++ ".jss", ++ ".mjs", ++ ".njs", ++ ".pac", ++ ".sjs", ++ ".ssjs", ++ ".xsjs", ++ ".xsjslib" ++]; ++var filenames = [ ++ "Jakefile" ++]; ++var interpreters = [ ++ "chakra", ++ "d8", ++ "gjs", ++ "js", ++ "node", ++ "qjs", ++ "rhino", ++ "v8", ++ "v8-shell" ++]; ++var languageId = 183; ++var JavaScript = { ++ name: name$2, ++ type: type, ++ tmScope: tmScope, ++ aceMode: aceMode, ++ codemirrorMode: codemirrorMode, ++ codemirrorMimeType: codemirrorMimeType, ++ color: color, ++ aliases: aliases, ++ extensions: extensions, ++ filenames: filenames, ++ interpreters: interpreters, ++ languageId: languageId ++}; ++ ++var JavaScript$1 = /*#__PURE__*/Object.freeze({ ++ __proto__: null, ++ name: name$2, ++ type: type, ++ tmScope: tmScope, ++ aceMode: aceMode, ++ codemirrorMode: codemirrorMode, ++ codemirrorMimeType: codemirrorMimeType, ++ color: color, ++ aliases: aliases, ++ extensions: extensions, ++ filenames: filenames, ++ interpreters: interpreters, ++ languageId: languageId, ++ 'default': JavaScript ++}); ++ ++var name$3 = "JSX"; ++var type$1 = "programming"; ++var group$3 = "JavaScript"; ++var extensions$1 = [ ++ ".jsx" ++]; ++var tmScope$1 = "source.js.jsx"; ++var aceMode$1 = "javascript"; ++var codemirrorMode$1 = "jsx"; ++var codemirrorMimeType$1 = "text/jsx"; ++var languageId$1 = 178; ++var JSX = { ++ name: name$3, ++ type: type$1, ++ group: group$3, ++ extensions: extensions$1, ++ tmScope: tmScope$1, ++ aceMode: aceMode$1, ++ codemirrorMode: codemirrorMode$1, ++ codemirrorMimeType: codemirrorMimeType$1, ++ languageId: languageId$1 ++}; ++ ++var JSX$1 = /*#__PURE__*/Object.freeze({ ++ __proto__: null, ++ name: name$3, ++ type: type$1, ++ group: group$3, ++ extensions: extensions$1, ++ tmScope: tmScope$1, ++ aceMode: aceMode$1, ++ codemirrorMode: codemirrorMode$1, ++ codemirrorMimeType: codemirrorMimeType$1, ++ languageId: languageId$1, ++ 'default': JSX ++}); ++ ++var name$4 = "TypeScript"; ++var type$2 = "programming"; ++var color$1 = "#2b7489"; ++var aliases$1 = [ ++ "ts" ++]; ++var interpreters$1 = [ ++ "deno", ++ "ts-node" ++]; ++var extensions$2 = [ ++ ".ts" ++]; ++var tmScope$2 = "source.ts"; ++var aceMode$2 = "typescript"; ++var codemirrorMode$2 = "javascript"; ++var codemirrorMimeType$2 = "application/typescript"; ++var languageId$2 = 378; ++var TypeScript = { ++ name: name$4, ++ type: type$2, ++ color: color$1, ++ aliases: aliases$1, ++ interpreters: interpreters$1, ++ extensions: extensions$2, ++ tmScope: tmScope$2, ++ aceMode: aceMode$2, ++ codemirrorMode: codemirrorMode$2, ++ codemirrorMimeType: codemirrorMimeType$2, ++ languageId: languageId$2 ++}; ++ ++var TypeScript$1 = /*#__PURE__*/Object.freeze({ ++ __proto__: null, ++ name: name$4, ++ type: type$2, ++ color: color$1, ++ aliases: aliases$1, ++ interpreters: interpreters$1, ++ extensions: extensions$2, ++ tmScope: tmScope$2, ++ aceMode: aceMode$2, ++ codemirrorMode: codemirrorMode$2, ++ codemirrorMimeType: codemirrorMimeType$2, ++ languageId: languageId$2, ++ 'default': TypeScript ++}); ++ ++var name$5 = "TSX"; ++var type$3 = "programming"; ++var group$4 = "TypeScript"; ++var extensions$3 = [ ++ ".tsx" ++]; ++var tmScope$3 = "source.tsx"; ++var aceMode$3 = "javascript"; ++var codemirrorMode$3 = "jsx"; ++var codemirrorMimeType$3 = "text/jsx"; ++var languageId$3 = 94901924; ++var TSX = { ++ name: name$5, ++ type: type$3, ++ group: group$4, ++ extensions: extensions$3, ++ tmScope: tmScope$3, ++ aceMode: aceMode$3, ++ codemirrorMode: codemirrorMode$3, ++ codemirrorMimeType: codemirrorMimeType$3, ++ languageId: languageId$3 ++}; ++ ++var TSX$1 = /*#__PURE__*/Object.freeze({ ++ __proto__: null, ++ name: name$5, ++ type: type$3, ++ group: group$4, ++ extensions: extensions$3, ++ tmScope: tmScope$3, ++ aceMode: aceMode$3, ++ codemirrorMode: codemirrorMode$3, ++ codemirrorMimeType: codemirrorMimeType$3, ++ languageId: languageId$3, ++ 'default': TSX ++}); ++ ++var name$6 = "JSON"; ++var type$4 = "data"; ++var tmScope$4 = "source.json"; ++var aceMode$4 = "json"; ++var codemirrorMode$4 = "javascript"; ++var codemirrorMimeType$4 = "application/json"; ++var searchable = false; ++var extensions$4 = [ ++ ".json", ++ ".avsc", ++ ".geojson", ++ ".gltf", ++ ".har", ++ ".ice", ++ ".JSON-tmLanguage", ++ ".jsonl", ++ ".mcmeta", ++ ".tfstate", ++ ".tfstate.backup", ++ ".topojson", ++ ".webapp", ++ ".webmanifest", ++ ".yy", ++ ".yyp" ++]; ++var filenames$1 = [ ++ ".arcconfig", ++ ".htmlhintrc", ++ ".tern-config", ++ ".tern-project", ++ ".watchmanconfig", ++ "composer.lock", ++ "mcmod.info" ++]; ++var languageId$4 = 174; ++var _JSON = { ++ name: name$6, ++ type: type$4, ++ tmScope: tmScope$4, ++ aceMode: aceMode$4, ++ codemirrorMode: codemirrorMode$4, ++ codemirrorMimeType: codemirrorMimeType$4, ++ searchable: searchable, ++ extensions: extensions$4, ++ filenames: filenames$1, ++ languageId: languageId$4 ++}; ++ ++var _JSON$1 = /*#__PURE__*/Object.freeze({ ++ __proto__: null, ++ name: name$6, ++ type: type$4, ++ tmScope: tmScope$4, ++ aceMode: aceMode$4, ++ codemirrorMode: codemirrorMode$4, ++ codemirrorMimeType: codemirrorMimeType$4, ++ searchable: searchable, ++ extensions: extensions$4, ++ filenames: filenames$1, ++ languageId: languageId$4, ++ 'default': _JSON ++}); ++ ++var name$7 = "JSON with Comments"; ++var type$5 = "data"; ++var group$5 = "JSON"; ++var tmScope$5 = "source.js"; ++var aceMode$5 = "javascript"; ++var codemirrorMode$5 = "javascript"; ++var codemirrorMimeType$5 = "text/javascript"; ++var aliases$2 = [ ++ "jsonc" ++]; ++var extensions$5 = [ ++ ".jsonc", ++ ".sublime-build", ++ ".sublime-commands", ++ ".sublime-completions", ++ ".sublime-keymap", ++ ".sublime-macro", ++ ".sublime-menu", ++ ".sublime-mousemap", ++ ".sublime-project", ++ ".sublime-settings", ++ ".sublime-theme", ++ ".sublime-workspace", ++ ".sublime_metrics", ++ ".sublime_session" ++]; ++var filenames$2 = [ ++ ".babelrc", ++ ".eslintrc.json", ++ ".jscsrc", ++ ".jshintrc", ++ ".jslintrc", ++ "jsconfig.json", ++ "language-configuration.json", ++ "tsconfig.json" ++]; ++var languageId$5 = 423; ++var JSON_with_Comments = { ++ name: name$7, ++ type: type$5, ++ group: group$5, ++ tmScope: tmScope$5, ++ aceMode: aceMode$5, ++ codemirrorMode: codemirrorMode$5, ++ codemirrorMimeType: codemirrorMimeType$5, ++ aliases: aliases$2, ++ extensions: extensions$5, ++ filenames: filenames$2, ++ languageId: languageId$5 ++}; ++ ++var JSON_with_Comments$1 = /*#__PURE__*/Object.freeze({ ++ __proto__: null, ++ name: name$7, ++ type: type$5, ++ group: group$5, ++ tmScope: tmScope$5, ++ aceMode: aceMode$5, ++ codemirrorMode: codemirrorMode$5, ++ codemirrorMimeType: codemirrorMimeType$5, ++ aliases: aliases$2, ++ extensions: extensions$5, ++ filenames: filenames$2, ++ languageId: languageId$5, ++ 'default': JSON_with_Comments ++}); ++ ++var name$8 = "JSON5"; ++var type$6 = "data"; ++var extensions$6 = [ ++ ".json5" ++]; ++var tmScope$6 = "source.js"; ++var aceMode$6 = "javascript"; ++var codemirrorMode$6 = "javascript"; ++var codemirrorMimeType$6 = "application/json"; ++var languageId$6 = 175; ++var JSON5 = { ++ name: name$8, ++ type: type$6, ++ extensions: extensions$6, ++ tmScope: tmScope$6, ++ aceMode: aceMode$6, ++ codemirrorMode: codemirrorMode$6, ++ codemirrorMimeType: codemirrorMimeType$6, ++ languageId: languageId$6 ++}; ++ ++var JSON5$1 = /*#__PURE__*/Object.freeze({ ++ __proto__: null, ++ name: name$8, ++ type: type$6, ++ extensions: extensions$6, ++ tmScope: tmScope$6, ++ aceMode: aceMode$6, ++ codemirrorMode: codemirrorMode$6, ++ codemirrorMimeType: codemirrorMimeType$6, ++ languageId: languageId$6, ++ 'default': JSON5 ++}); ++ ++var require$$0$1 = getCjsExportFromNamespace(JavaScript$1); ++ ++var require$$1$1 = getCjsExportFromNamespace(JSX$1); ++ ++var require$$2 = getCjsExportFromNamespace(TypeScript$1); ++ ++var require$$3 = getCjsExportFromNamespace(TSX$1); ++ ++var require$$4$1 = getCjsExportFromNamespace(_JSON$1); ++ ++var require$$5 = getCjsExportFromNamespace(JSON_with_Comments$1); ++ ++var require$$6 = getCjsExportFromNamespace(JSON5$1); ++ ++const languages = [createLanguage(require$$0$1, data => ({ ++ since: "0.0.0", ++ parsers: ["babel", "flow"], ++ vscodeLanguageIds: ["javascript", "mongo"], ++ interpreters: data.interpreters.concat(["nodejs"]) ++})), createLanguage(require$$0$1, () => ({ ++ name: "Flow", ++ since: "0.0.0", ++ parsers: ["babel", "flow"], ++ vscodeLanguageIds: ["javascript"], ++ aliases: [], ++ filenames: [], ++ extensions: [".js.flow"] ++})), createLanguage(require$$1$1, () => ({ ++ since: "0.0.0", ++ parsers: ["babel", "flow"], ++ vscodeLanguageIds: ["javascriptreact"] ++})), createLanguage(require$$2, () => ({ ++ since: "1.4.0", ++ parsers: ["typescript", "babel-ts"], ++ vscodeLanguageIds: ["typescript"] ++})), createLanguage(require$$3, () => ({ ++ since: "1.4.0", ++ parsers: ["typescript", "babel-ts"], ++ vscodeLanguageIds: ["typescriptreact"] ++})), createLanguage(require$$4$1, () => ({ ++ name: "JSON.stringify", ++ since: "1.13.0", ++ parsers: ["json-stringify"], ++ vscodeLanguageIds: ["json"], ++ extensions: [], ++ // .json file defaults to json instead of json-stringify ++ filenames: ["package.json", "package-lock.json", "composer.json"] ++})), createLanguage(require$$4$1, data => ({ ++ since: "1.5.0", ++ parsers: ["json"], ++ vscodeLanguageIds: ["json"], ++ filenames: data.filenames.concat([".prettierrc"]) ++})), createLanguage(require$$5, data => ({ ++ since: "1.5.0", ++ parsers: ["json"], ++ vscodeLanguageIds: ["jsonc"], ++ filenames: data.filenames.concat([".eslintrc"]) ++})), createLanguage(require$$6, () => ({ ++ since: "1.13.0", ++ parsers: ["json5"], ++ vscodeLanguageIds: ["json5"] ++}))]; ++const printers = { ++ estree: printerEstree, ++ "estree-json": printerEstreeJson ++}; ++var languageJs = { ++ languages, ++ options: options$2, ++ printers ++}; ++ ++function clean$2(ast, newObj, parent) { ++ ["raw", // front-matter ++ "raws", "sourceIndex", "source", "before", "after", "trailingComma"].forEach(name => { ++ delete newObj[name]; ++ }); ++ ++ if (ast.type === "yaml") { ++ delete newObj.value; ++ } // --insert-pragma ++ ++ ++ if (ast.type === "css-comment" && parent.type === "css-root" && parent.nodes.length !== 0 && ( // first non-front-matter comment ++ parent.nodes[0] === ast || (parent.nodes[0].type === "yaml" || parent.nodes[0].type === "toml") && parent.nodes[1] === ast)) { ++ /** ++ * something ++ * ++ * @format ++ */ ++ delete newObj.text; // standalone pragma ++ ++ if (/^\*\s*@(format|prettier)\s*$/.test(ast.text)) { ++ return null; ++ } ++ } ++ ++ if (ast.type === "media-query" || ast.type === "media-query-list" || ast.type === "media-feature-expression") { ++ delete newObj.value; ++ } ++ ++ if (ast.type === "css-rule") { ++ delete newObj.params; ++ } ++ ++ if (ast.type === "selector-combinator") { ++ newObj.value = newObj.value.replace(/\s+/g, " "); ++ } ++ ++ if (ast.type === "media-feature") { ++ newObj.value = newObj.value.replace(/ /g, ""); ++ } ++ ++ if (ast.type === "value-word" && (ast.isColor && ast.isHex || ["initial", "inherit", "unset", "revert"].includes(newObj.value.replace().toLowerCase())) || ast.type === "media-feature" || ast.type === "selector-root-invalid" || ast.type === "selector-pseudo") { ++ newObj.value = newObj.value.toLowerCase(); ++ } ++ ++ if (ast.type === "css-decl") { ++ newObj.prop = newObj.prop.toLowerCase(); ++ } ++ ++ if (ast.type === "css-atrule" || ast.type === "css-import") { ++ newObj.name = newObj.name.toLowerCase(); ++ } ++ ++ if (ast.type === "value-number") { ++ newObj.unit = newObj.unit.toLowerCase(); ++ } ++ ++ if ((ast.type === "media-feature" || ast.type === "media-keyword" || ast.type === "media-type" || ast.type === "media-unknown" || ast.type === "media-url" || ast.type === "media-value" || ast.type === "selector-attribute" || ast.type === "selector-string" || ast.type === "selector-class" || ast.type === "selector-combinator" || ast.type === "value-string") && newObj.value) { ++ newObj.value = cleanCSSStrings(newObj.value); ++ } ++ ++ if (ast.type === "selector-attribute") { ++ newObj.attribute = newObj.attribute.trim(); ++ ++ if (newObj.namespace) { ++ if (typeof newObj.namespace === "string") { ++ newObj.namespace = newObj.namespace.trim(); ++ ++ if (newObj.namespace.length === 0) { ++ newObj.namespace = true; ++ } ++ } ++ } ++ ++ if (newObj.value) { ++ newObj.value = newObj.value.trim().replace(/^['"]|['"]$/g, ""); ++ delete newObj.quoted; ++ } ++ } ++ ++ if ((ast.type === "media-value" || ast.type === "media-type" || ast.type === "value-number" || ast.type === "selector-root-invalid" || ast.type === "selector-class" || ast.type === "selector-combinator" || ast.type === "selector-tag") && newObj.value) { ++ newObj.value = newObj.value.replace(/([\d.eE+-]+)([a-zA-Z]*)/g, (match, numStr, unit) => { ++ const num = Number(numStr); ++ return isNaN(num) ? match : num + unit.toLowerCase(); ++ }); ++ } ++ ++ if (ast.type === "selector-tag") { ++ const lowercasedValue = ast.value.toLowerCase(); ++ ++ if (["from", "to"].includes(lowercasedValue)) { ++ newObj.value = lowercasedValue; ++ } ++ } // Workaround when `postcss-values-parser` parse `not`, `and` or `or` keywords as `value-func` ++ ++ ++ if (ast.type === "css-atrule" && ast.name.toLowerCase() === "supports") { ++ delete newObj.value; ++ } // Workaround for SCSS nested properties ++ ++ ++ if (ast.type === "selector-unknown") { ++ delete newObj.value; ++ } ++} ++ ++function cleanCSSStrings(value) { ++ return value.replace(/'/g, '"').replace(/\\([^a-fA-F\d])/g, "$1"); ++} ++ ++var clean_1$1 = clean$2; ++ ++const { ++ builders: { ++ hardline: hardline$6, ++ literalline: literalline$3, ++ concat: concat$8, ++ markAsRoot: markAsRoot$1 ++ }, ++ utils: { ++ mapDoc: mapDoc$3 ++ } ++} = document; ++ ++function embed$1(path, print, textToDoc ++/*, options */ ++) { ++ const node = path.getValue(); ++ ++ if (node.type === "yaml") { ++ return markAsRoot$1(concat$8(["---", hardline$6, node.value.trim() ? replaceNewlinesWithLiterallines(textToDoc(node.value, { ++ parser: "yaml" ++ })) : "", "---", hardline$6])); ++ } ++ ++ return null; ++ ++ function replaceNewlinesWithLiterallines(doc) { ++ return mapDoc$3(doc, currentDoc => typeof currentDoc === "string" && currentDoc.includes("\n") ? concat$8(currentDoc.split(/(\n)/g).map((v, i) => i % 2 === 0 ? v : literalline$3)) : currentDoc); ++ } ++} ++ ++var embed_1$1 = embed$1; ++ ++const DELIMITER_MAP = { ++ "---": "yaml", ++ "+++": "toml" ++}; ++ ++function parse$4(text) { ++ const delimiterRegex = Object.keys(DELIMITER_MAP).map(escapeStringRegexp$2).join("|"); ++ const match = text.match( // trailing spaces after delimiters are allowed ++ new RegExp(`^(${delimiterRegex})[^\\n\\S]*\\n(?:([\\s\\S]*?)\\n)?\\1[^\\n\\S]*(\\n|$)`)); ++ ++ if (match === null) { ++ return { ++ frontMatter: null, ++ content: text ++ }; ++ } ++ ++ const [raw, delimiter, value] = match; ++ return { ++ frontMatter: { ++ type: DELIMITER_MAP[delimiter], ++ value, ++ raw: raw.replace(/\n$/, "") ++ }, ++ content: raw.replace(/[^\n]/g, " ") + text.slice(raw.length) ++ }; ++} ++ ++var frontMatter = parse$4; ++ ++function hasPragma$1(text) { ++ return pragma.hasPragma(frontMatter(text).content); ++} ++ ++function insertPragma$2(text) { ++ const { ++ frontMatter: frontMatter$1, ++ content ++ } = frontMatter(text); ++ return (frontMatter$1 ? frontMatter$1.raw + "\n\n" : "") + pragma.insertPragma(content); ++} ++ ++var pragma$1 = { ++ hasPragma: hasPragma$1, ++ insertPragma: insertPragma$2 ++}; ++ ++var lineColumnToIndex = function (lineColumn, text) { ++ let index = 0; ++ ++ for (let i = 0; i < lineColumn.line - 1; ++i) { ++ index = text.indexOf("\n", index) + 1; ++ ++ if (index === -1) { ++ return -1; ++ } ++ } ++ ++ return index + lineColumn.column; ++}; ++ ++const { ++ getLast: getLast$3, ++ skipEverythingButNewLine: skipEverythingButNewLine$2 ++} = util$1; ++ ++function calculateLocStart(node, text) { ++ if (node.source) { ++ return lineColumnToIndex(node.source.start, text) - 1; ++ } ++ ++ return null; ++} ++ ++function calculateLocEnd(node, text) { ++ if (node.type === "css-comment" && node.inline) { ++ return skipEverythingButNewLine$2(text, node.source.startOffset); ++ } ++ ++ const endNode = node.nodes && getLast$3(node.nodes); ++ ++ if (endNode && node.source && !node.source.end) { ++ node = endNode; ++ } ++ ++ if (node.source && node.source.end) { ++ return lineColumnToIndex(node.source.end, text); ++ } ++ ++ return null; ++} ++ ++function calculateLoc(node, text) { ++ if (node && typeof node === "object") { ++ if (node.source) { ++ node.source.startOffset = calculateLocStart(node, text); ++ node.source.endOffset = calculateLocEnd(node, text); ++ } ++ ++ for (const key in node) { ++ calculateLoc(node[key], text); ++ } ++ } ++} ++/** ++ * Workaround for a bug: quotes in inline comments corrupt loc data of subsequent nodes. ++ * This function replaces the quotes with U+FFFE and U+FFFF. Later, when the comments are printed, ++ * their content is extracted from the original text or restored by replacing the placeholder ++ * characters back with quotes. ++ * - https://github.com/prettier/prettier/issues/7780 ++ * - https://github.com/shellscape/postcss-less/issues/145 ++ * - About noncharacters (U+FFFE and U+FFFF): http://www.unicode.org/faq/private_use.html#nonchar1 ++ * @param text {string} ++ */ ++ ++ ++function replaceQuotesInInlineComments(text) { ++ /** @typedef { 'initial' | 'single-quotes' | 'double-quotes' | 'url' | 'comment-block' | 'comment-inline' } State */ ++ ++ /** @type {State} */ ++ let state = "initial"; ++ /** @type {State} */ ++ ++ let stateToReturnFromQuotes = "initial"; ++ let inlineCommentStartIndex; ++ let inlineCommentContainsQuotes = false; ++ const inlineCommentsToReplace = []; ++ ++ for (let i = 0; i < text.length; i++) { ++ const c = text[i]; ++ ++ switch (state) { ++ case "initial": ++ if (c === "'") { ++ state = "single-quotes"; ++ continue; ++ } ++ ++ if (c === '"') { ++ state = "double-quotes"; ++ continue; ++ } ++ ++ if ((c === "u" || c === "U") && text.slice(i, i + 4).toLowerCase() === "url(") { ++ state = "url"; ++ i += 3; ++ continue; ++ } ++ ++ if (c === "*" && text[i - 1] === "/") { ++ state = "comment-block"; ++ continue; ++ } ++ ++ if (c === "/" && text[i - 1] === "/") { ++ state = "comment-inline"; ++ inlineCommentStartIndex = i - 1; ++ continue; ++ } ++ ++ continue; ++ ++ case "single-quotes": ++ if (c === "'" && text[i - 1] !== "\\") { ++ state = stateToReturnFromQuotes; ++ stateToReturnFromQuotes = "initial"; ++ } ++ ++ if (c === "\n" || c === "\r") { ++ return text; // invalid input ++ } ++ ++ continue; ++ ++ case "double-quotes": ++ if (c === '"' && text[i - 1] !== "\\") { ++ state = stateToReturnFromQuotes; ++ stateToReturnFromQuotes = "initial"; ++ } ++ ++ if (c === "\n" || c === "\r") { ++ return text; // invalid input ++ } ++ ++ continue; ++ ++ case "url": ++ if (c === ")") { ++ state = "initial"; ++ } ++ ++ if (c === "\n" || c === "\r") { ++ return text; // invalid input ++ } ++ ++ if (c === "'") { ++ state = "single-quotes"; ++ stateToReturnFromQuotes = "url"; ++ continue; ++ } ++ ++ if (c === '"') { ++ state = "double-quotes"; ++ stateToReturnFromQuotes = "url"; ++ continue; ++ } ++ ++ continue; ++ ++ case "comment-block": ++ if (c === "/" && text[i - 1] === "*") { ++ state = "initial"; ++ } ++ ++ continue; ++ ++ case "comment-inline": ++ if (c === '"' || c === "'") { ++ inlineCommentContainsQuotes = true; ++ } ++ ++ if (c === "\n" || c === "\r") { ++ if (inlineCommentContainsQuotes) { ++ inlineCommentsToReplace.push([inlineCommentStartIndex, i]); ++ } ++ ++ state = "initial"; ++ inlineCommentContainsQuotes = false; ++ } ++ ++ continue; ++ } ++ } ++ ++ for (const [start, end] of inlineCommentsToReplace) { ++ text = text.slice(0, start) + text.slice(start, end).replace(/'/g, "\ufffe").replace(/"/g, "\uffff") + text.slice(end); ++ } ++ ++ return text; ++} ++ ++function restoreQuotesInInlineComments(text) { ++ return text.replace(/\ufffe/g, "'").replace(/\uffff/g, '"'); ++} ++ ++var loc$1 = { ++ calculateLoc, ++ replaceQuotesInInlineComments, ++ restoreQuotesInInlineComments ++}; ++ ++const colorAdjusterFunctions = ["red", "green", "blue", "alpha", "a", "rgb", "hue", "h", "saturation", "s", "lightness", "l", "whiteness", "w", "blackness", "b", "tint", "shade", "blend", "blenda", "contrast", "hsl", "hsla", "hwb", "hwba"]; ++ ++function getAncestorCounter(path, typeOrTypes) { ++ const types = [].concat(typeOrTypes); ++ let counter = -1; ++ let ancestorNode; ++ ++ while (ancestorNode = path.getParentNode(++counter)) { ++ if (types.includes(ancestorNode.type)) { ++ return counter; ++ } ++ } ++ ++ return -1; ++} ++ ++function getAncestorNode(path, typeOrTypes) { ++ const counter = getAncestorCounter(path, typeOrTypes); ++ return counter === -1 ? null : path.getParentNode(counter); ++} ++ ++function getPropOfDeclNode(path) { ++ const declAncestorNode = getAncestorNode(path, "css-decl"); ++ return declAncestorNode && declAncestorNode.prop && declAncestorNode.prop.toLowerCase(); ++} ++ ++function isSCSS(parser, text) { ++ const hasExplicitParserChoice = parser === "less" || parser === "scss"; ++ const IS_POSSIBLY_SCSS = /(\w\s*: [^}:]+|#){|@import[^\n]+(url|,)/; ++ return hasExplicitParserChoice ? parser === "scss" : IS_POSSIBLY_SCSS.test(text); ++} ++ ++function isWideKeywords(value) { ++ return ["initial", "inherit", "unset", "revert"].includes(value.toLowerCase()); ++} ++ ++function isKeyframeAtRuleKeywords(path, value) { ++ const atRuleAncestorNode = getAncestorNode(path, "css-atrule"); ++ return atRuleAncestorNode && atRuleAncestorNode.name && atRuleAncestorNode.name.toLowerCase().endsWith("keyframes") && ["from", "to"].includes(value.toLowerCase()); ++} ++ ++function maybeToLowerCase(value) { ++ return value.includes("$") || value.includes("@") || value.includes("#") || value.startsWith("%") || value.startsWith("--") || value.startsWith(":--") || value.includes("(") && value.includes(")") ? value : value.toLowerCase(); ++} ++ ++function insideValueFunctionNode(path, functionName) { ++ const funcAncestorNode = getAncestorNode(path, "value-func"); ++ return funcAncestorNode && funcAncestorNode.value && funcAncestorNode.value.toLowerCase() === functionName; ++} ++ ++function insideICSSRuleNode(path) { ++ const ruleAncestorNode = getAncestorNode(path, "css-rule"); ++ return ruleAncestorNode && ruleAncestorNode.raws && ruleAncestorNode.raws.selector && (ruleAncestorNode.raws.selector.startsWith(":import") || ruleAncestorNode.raws.selector.startsWith(":export")); ++} ++ ++function insideAtRuleNode(path, atRuleNameOrAtRuleNames) { ++ const atRuleNames = [].concat(atRuleNameOrAtRuleNames); ++ const atRuleAncestorNode = getAncestorNode(path, "css-atrule"); ++ return atRuleAncestorNode && atRuleNames.includes(atRuleAncestorNode.name.toLowerCase()); ++} ++ ++function insideURLFunctionInImportAtRuleNode(path) { ++ const node = path.getValue(); ++ const atRuleAncestorNode = getAncestorNode(path, "css-atrule"); ++ return atRuleAncestorNode && atRuleAncestorNode.name === "import" && node.groups[0].value === "url" && node.groups.length === 2; ++} ++ ++function isURLFunctionNode(node) { ++ return node.type === "value-func" && node.value.toLowerCase() === "url"; ++} ++ ++function isLastNode(path, node) { ++ const parentNode = path.getParentNode(); ++ ++ if (!parentNode) { ++ return false; ++ } ++ ++ const { ++ nodes ++ } = parentNode; ++ return nodes && nodes.indexOf(node) === nodes.length - 1; ++} ++ ++function isDetachedRulesetDeclarationNode(node) { ++ // If a Less file ends up being parsed with the SCSS parser, Less ++ // variable declarations will be parsed as atrules with names ending ++ // with a colon, so keep the original case then. ++ if (!node.selector) { ++ return false; ++ } ++ ++ return typeof node.selector === "string" && /^@.+:.*$/.test(node.selector) || node.selector.value && /^@.+:.*$/.test(node.selector.value); ++} ++ ++function isForKeywordNode(node) { ++ return node.type === "value-word" && ["from", "through", "end"].includes(node.value); ++} ++ ++function isIfElseKeywordNode(node) { ++ return node.type === "value-word" && ["and", "or", "not"].includes(node.value); ++} ++ ++function isEachKeywordNode(node) { ++ return node.type === "value-word" && node.value === "in"; ++} ++ ++function isMultiplicationNode(node) { ++ return node.type === "value-operator" && node.value === "*"; ++} ++ ++function isDivisionNode(node) { ++ return node.type === "value-operator" && node.value === "/"; ++} ++ ++function isAdditionNode(node) { ++ return node.type === "value-operator" && node.value === "+"; ++} ++ ++function isSubtractionNode(node) { ++ return node.type === "value-operator" && node.value === "-"; ++} ++ ++function isModuloNode(node) { ++ return node.type === "value-operator" && node.value === "%"; ++} ++ ++function isMathOperatorNode(node) { ++ return isMultiplicationNode(node) || isDivisionNode(node) || isAdditionNode(node) || isSubtractionNode(node) || isModuloNode(node); ++} ++ ++function isEqualityOperatorNode(node) { ++ return node.type === "value-word" && ["==", "!="].includes(node.value); ++} ++ ++function isRelationalOperatorNode(node) { ++ return node.type === "value-word" && ["<", ">", "<=", ">="].includes(node.value); ++} ++ ++function isSCSSControlDirectiveNode(node) { ++ return node.type === "css-atrule" && ["if", "else", "for", "each", "while"].includes(node.name); ++} ++ ++function isSCSSNestedPropertyNode(node) { ++ if (!node.selector) { ++ return false; ++ } ++ ++ return node.selector.replace(/\/\*.*?\*\//, "").replace(/\/\/.*?\n/, "").trim().endsWith(":"); ++} ++ ++function isDetachedRulesetCallNode(node) { ++ return node.raws && node.raws.params && /^\(\s*\)$/.test(node.raws.params); ++} ++ ++function isTemplatePlaceholderNode(node) { ++ return node.name.startsWith("prettier-placeholder"); ++} ++ ++function isTemplatePropNode(node) { ++ return node.prop.startsWith("@prettier-placeholder"); ++} ++ ++function isPostcssSimpleVarNode(currentNode, nextNode) { ++ return currentNode.value === "$$" && currentNode.type === "value-func" && nextNode && nextNode.type === "value-word" && !nextNode.raws.before; ++} ++ ++function hasComposesNode(node) { ++ return node.value && node.value.type === "value-root" && node.value.group && node.value.group.type === "value-value" && node.prop.toLowerCase() === "composes"; ++} ++ ++function hasParensAroundNode(node) { ++ return node.value && node.value.group && node.value.group.group && node.value.group.group.type === "value-paren_group" && node.value.group.group.open !== null && node.value.group.group.close !== null; ++} ++ ++function hasEmptyRawBefore(node) { ++ return node.raws && node.raws.before === ""; ++} ++ ++function isKeyValuePairNode(node) { ++ return node.type === "value-comma_group" && node.groups && node.groups[1] && node.groups[1].type === "value-colon"; ++} ++ ++function isKeyValuePairInParenGroupNode(node) { ++ return node.type === "value-paren_group" && node.groups && node.groups[0] && isKeyValuePairNode(node.groups[0]); ++} ++ ++function isSCSSMapItemNode(path) { ++ const node = path.getValue(); // Ignore empty item (i.e. `$key: ()`) ++ ++ if (node.groups.length === 0) { ++ return false; ++ } ++ ++ const parentParentNode = path.getParentNode(1); // Check open parens contain key/value pair (i.e. `(key: value)` and `(key: (value, other-value)`) ++ ++ if (!isKeyValuePairInParenGroupNode(node) && !(parentParentNode && isKeyValuePairInParenGroupNode(parentParentNode))) { ++ return false; ++ } ++ ++ const declNode = getAncestorNode(path, "css-decl"); // SCSS map declaration (i.e. `$map: (key: value, other-key: other-value)`) ++ ++ if (declNode && declNode.prop && declNode.prop.startsWith("$")) { ++ return true; ++ } // List as value of key inside SCSS map (i.e. `$map: (key: (value other-value other-other-value))`) ++ ++ ++ if (isKeyValuePairInParenGroupNode(parentParentNode)) { ++ return true; ++ } // SCSS Map is argument of function (i.e. `func((key: value, other-key: other-value))`) ++ ++ ++ if (parentParentNode.type === "value-func") { ++ return true; ++ } ++ ++ return false; ++} ++ ++function isInlineValueCommentNode(node) { ++ return node.type === "value-comment" && node.inline; ++} ++ ++function isHashNode(node) { ++ return node.type === "value-word" && node.value === "#"; ++} ++ ++function isLeftCurlyBraceNode(node) { ++ return node.type === "value-word" && node.value === "{"; ++} ++ ++function isRightCurlyBraceNode(node) { ++ return node.type === "value-word" && node.value === "}"; ++} ++ ++function isWordNode(node) { ++ return ["value-word", "value-atword"].includes(node.type); ++} ++ ++function isColonNode(node) { ++ return node.type === "value-colon"; ++} ++ ++function isMediaAndSupportsKeywords(node) { ++ return node.value && ["not", "and", "or"].includes(node.value.toLowerCase()); ++} ++ ++function isColorAdjusterFuncNode(node) { ++ if (node.type !== "value-func") { ++ return false; ++ } ++ ++ return colorAdjusterFunctions.includes(node.value.toLowerCase()); ++} // TODO: only check `less` when we don't use `less` to parse `css` ++ ++ ++function isLessParser(options) { ++ return options.parser === "css" || options.parser === "less"; ++} ++ ++function lastLineHasInlineComment(text) { ++ return /\/\//.test(text.split(/[\r\n]/).pop()); ++} ++ ++var utils$7 = { ++ getAncestorCounter, ++ getAncestorNode, ++ getPropOfDeclNode, ++ maybeToLowerCase, ++ insideValueFunctionNode, ++ insideICSSRuleNode, ++ insideAtRuleNode, ++ insideURLFunctionInImportAtRuleNode, ++ isKeyframeAtRuleKeywords, ++ isWideKeywords, ++ isSCSS, ++ isLastNode, ++ isLessParser, ++ isSCSSControlDirectiveNode, ++ isDetachedRulesetDeclarationNode, ++ isRelationalOperatorNode, ++ isEqualityOperatorNode, ++ isMultiplicationNode, ++ isDivisionNode, ++ isAdditionNode, ++ isSubtractionNode, ++ isModuloNode, ++ isMathOperatorNode, ++ isEachKeywordNode, ++ isForKeywordNode, ++ isURLFunctionNode, ++ isIfElseKeywordNode, ++ hasComposesNode, ++ hasParensAroundNode, ++ hasEmptyRawBefore, ++ isSCSSNestedPropertyNode, ++ isDetachedRulesetCallNode, ++ isTemplatePlaceholderNode, ++ isTemplatePropNode, ++ isPostcssSimpleVarNode, ++ isKeyValuePairNode, ++ isKeyValuePairInParenGroupNode, ++ isSCSSMapItemNode, ++ isInlineValueCommentNode, ++ isHashNode, ++ isLeftCurlyBraceNode, ++ isRightCurlyBraceNode, ++ isWordNode, ++ isColonNode, ++ isMediaAndSupportsKeywords, ++ isColorAdjusterFuncNode, ++ lastLineHasInlineComment ++}; ++ ++const { ++ insertPragma: insertPragma$3 ++} = pragma$1; ++const { ++ printNumber: printNumber$2, ++ printString: printString$2, ++ hasIgnoreComment: hasIgnoreComment$3, ++ hasNewline: hasNewline$5 ++} = util$1; ++const { ++ isNextLineEmpty: isNextLineEmpty$3 ++} = utilShared; ++const { ++ restoreQuotesInInlineComments: restoreQuotesInInlineComments$1 ++} = loc$1; ++const { ++ builders: { ++ concat: concat$9, ++ join: join$6, ++ line: line$5, ++ hardline: hardline$7, ++ softline: softline$3, ++ group: group$6, ++ fill: fill$4, ++ indent: indent$5, ++ dedent: dedent$2, ++ ifBreak: ifBreak$2 ++ }, ++ utils: { ++ removeLines: removeLines$2 ++ } ++} = document; ++const { ++ getAncestorNode: getAncestorNode$1, ++ getPropOfDeclNode: getPropOfDeclNode$1, ++ maybeToLowerCase: maybeToLowerCase$1, ++ insideValueFunctionNode: insideValueFunctionNode$1, ++ insideICSSRuleNode: insideICSSRuleNode$1, ++ insideAtRuleNode: insideAtRuleNode$1, ++ insideURLFunctionInImportAtRuleNode: insideURLFunctionInImportAtRuleNode$1, ++ isKeyframeAtRuleKeywords: isKeyframeAtRuleKeywords$1, ++ isWideKeywords: isWideKeywords$1, ++ isSCSS: isSCSS$1, ++ isLastNode: isLastNode$1, ++ isLessParser: isLessParser$1, ++ isSCSSControlDirectiveNode: isSCSSControlDirectiveNode$1, ++ isDetachedRulesetDeclarationNode: isDetachedRulesetDeclarationNode$1, ++ isRelationalOperatorNode: isRelationalOperatorNode$1, ++ isEqualityOperatorNode: isEqualityOperatorNode$1, ++ isMultiplicationNode: isMultiplicationNode$1, ++ isDivisionNode: isDivisionNode$1, ++ isAdditionNode: isAdditionNode$1, ++ isSubtractionNode: isSubtractionNode$1, ++ isMathOperatorNode: isMathOperatorNode$1, ++ isEachKeywordNode: isEachKeywordNode$1, ++ isForKeywordNode: isForKeywordNode$1, ++ isURLFunctionNode: isURLFunctionNode$1, ++ isIfElseKeywordNode: isIfElseKeywordNode$1, ++ hasComposesNode: hasComposesNode$1, ++ hasParensAroundNode: hasParensAroundNode$1, ++ hasEmptyRawBefore: hasEmptyRawBefore$1, ++ isKeyValuePairNode: isKeyValuePairNode$1, ++ isDetachedRulesetCallNode: isDetachedRulesetCallNode$1, ++ isTemplatePlaceholderNode: isTemplatePlaceholderNode$1, ++ isTemplatePropNode: isTemplatePropNode$1, ++ isPostcssSimpleVarNode: isPostcssSimpleVarNode$1, ++ isSCSSMapItemNode: isSCSSMapItemNode$1, ++ isInlineValueCommentNode: isInlineValueCommentNode$1, ++ isHashNode: isHashNode$1, ++ isLeftCurlyBraceNode: isLeftCurlyBraceNode$1, ++ isRightCurlyBraceNode: isRightCurlyBraceNode$1, ++ isWordNode: isWordNode$1, ++ isColonNode: isColonNode$1, ++ isMediaAndSupportsKeywords: isMediaAndSupportsKeywords$1, ++ isColorAdjusterFuncNode: isColorAdjusterFuncNode$1, ++ lastLineHasInlineComment: lastLineHasInlineComment$1 ++} = utils$7; ++ ++function shouldPrintComma$1(options) { ++ switch (options.trailingComma) { ++ case "all": ++ case "es5": ++ return true; ++ ++ case "none": ++ default: ++ return false; ++ } ++} ++ ++function genericPrint$2(path, options, print) { ++ const node = path.getValue(); ++ /* istanbul ignore if */ ++ ++ if (!node) { ++ return ""; ++ } ++ ++ if (typeof node === "string") { ++ return node; ++ } ++ ++ switch (node.type) { ++ case "yaml": ++ case "toml": ++ return concat$9([node.raw, hardline$7]); ++ ++ case "css-root": ++ { ++ const nodes = printNodeSequence(path, options, print); ++ ++ if (nodes.parts.length) { ++ return concat$9([nodes, options.__isHTMLStyleAttribute ? "" : hardline$7]); ++ } ++ ++ return nodes; ++ } ++ ++ case "css-comment": ++ { ++ const isInlineComment = node.inline || node.raws.inline; ++ const text = options.originalText.slice(options.locStart(node), options.locEnd(node)); ++ return isInlineComment ? text.trimEnd() : text; ++ } ++ ++ case "css-rule": ++ { ++ return concat$9([path.call(print, "selector"), node.important ? " !important" : "", node.nodes ? concat$9([node.selector && node.selector.type === "selector-unknown" && lastLineHasInlineComment$1(node.selector.value) ? line$5 : " ", "{", node.nodes.length > 0 ? indent$5(concat$9([hardline$7, printNodeSequence(path, options, print)])) : "", hardline$7, "}", isDetachedRulesetDeclarationNode$1(node) ? ";" : ""]) : ";"]); ++ } ++ ++ case "css-decl": ++ { ++ const parentNode = path.getParentNode(); ++ return concat$9([node.raws.before.replace(/[\s;]/g, ""), insideICSSRuleNode$1(path) ? node.prop : maybeToLowerCase$1(node.prop), node.raws.between.trim() === ":" ? ":" : node.raws.between.trim(), node.extend ? "" : " ", hasComposesNode$1(node) ? removeLines$2(path.call(print, "value")) : path.call(print, "value"), node.raws.important ? node.raws.important.replace(/\s*!\s*important/i, " !important") : node.important ? " !important" : "", node.raws.scssDefault ? node.raws.scssDefault.replace(/\s*!default/i, " !default") : node.scssDefault ? " !default" : "", node.raws.scssGlobal ? node.raws.scssGlobal.replace(/\s*!global/i, " !global") : node.scssGlobal ? " !global" : "", node.nodes ? concat$9([" {", indent$5(concat$9([softline$3, printNodeSequence(path, options, print)])), softline$3, "}"]) : isTemplatePropNode$1(node) && !parentNode.raws.semicolon && options.originalText[options.locEnd(node) - 1] !== ";" ? "" : ";"]); ++ } ++ ++ case "css-atrule": ++ { ++ const parentNode = path.getParentNode(); ++ const isTemplatePlaceholderNodeWithoutSemiColon = isTemplatePlaceholderNode$1(node) && !parentNode.raws.semicolon && options.originalText[options.locEnd(node) - 1] !== ";"; ++ ++ if (isLessParser$1(options)) { ++ if (node.mixin) { ++ return concat$9([path.call(print, "selector"), node.important ? " !important" : "", isTemplatePlaceholderNodeWithoutSemiColon ? "" : ";"]); ++ } ++ ++ if (node.function) { ++ return concat$9([node.name, concat$9([path.call(print, "params")]), isTemplatePlaceholderNodeWithoutSemiColon ? "" : ";"]); ++ } ++ ++ if (node.variable) { ++ return concat$9(["@", node.name, ": ", node.value ? concat$9([path.call(print, "value")]) : "", node.raws.between.trim() ? node.raws.between.trim() + " " : "", node.nodes ? concat$9(["{", indent$5(concat$9([node.nodes.length > 0 ? softline$3 : "", printNodeSequence(path, options, print)])), softline$3, "}"]) : "", isTemplatePlaceholderNodeWithoutSemiColon ? "" : ";"]); ++ } ++ } ++ ++ return concat$9(["@", // If a Less file ends up being parsed with the SCSS parser, Less ++ // variable declarations will be parsed as at-rules with names ending ++ // with a colon, so keep the original case then. ++ isDetachedRulesetCallNode$1(node) || node.name.endsWith(":") ? node.name : maybeToLowerCase$1(node.name), node.params ? concat$9([isDetachedRulesetCallNode$1(node) ? "" : isTemplatePlaceholderNode$1(node) && /^\s*\n/.test(node.raws.afterName) ? /^\s*\n\s*\n/.test(node.raws.afterName) ? concat$9([hardline$7, hardline$7]) : hardline$7 : " ", path.call(print, "params")]) : "", node.selector ? indent$5(concat$9([" ", path.call(print, "selector")])) : "", node.value ? group$6(concat$9([" ", path.call(print, "value"), isSCSSControlDirectiveNode$1(node) ? hasParensAroundNode$1(node) ? " " : line$5 : ""])) : node.name === "else" ? " " : "", node.nodes ? concat$9([isSCSSControlDirectiveNode$1(node) ? "" : " ", "{", indent$5(concat$9([node.nodes.length > 0 ? softline$3 : "", printNodeSequence(path, options, print)])), softline$3, "}"]) : isTemplatePlaceholderNodeWithoutSemiColon ? "" : ";"]); ++ } ++ // postcss-media-query-parser ++ ++ case "media-query-list": ++ { ++ const parts = []; ++ path.each(childPath => { ++ const node = childPath.getValue(); ++ ++ if (node.type === "media-query" && node.value === "") { ++ return; ++ } ++ ++ parts.push(childPath.call(print)); ++ }, "nodes"); ++ return group$6(indent$5(join$6(line$5, parts))); ++ } ++ ++ case "media-query": ++ { ++ return concat$9([join$6(" ", path.map(print, "nodes")), isLastNode$1(path, node) ? "" : ","]); ++ } ++ ++ case "media-type": ++ { ++ return adjustNumbers(adjustStrings(node.value, options)); ++ } ++ ++ case "media-feature-expression": ++ { ++ if (!node.nodes) { ++ return node.value; ++ } ++ ++ return concat$9(["(", concat$9(path.map(print, "nodes")), ")"]); ++ } ++ ++ case "media-feature": ++ { ++ return maybeToLowerCase$1(adjustStrings(node.value.replace(/ +/g, " "), options)); ++ } ++ ++ case "media-colon": ++ { ++ return concat$9([node.value, " "]); ++ } ++ ++ case "media-value": ++ { ++ return adjustNumbers(adjustStrings(node.value, options)); ++ } ++ ++ case "media-keyword": ++ { ++ return adjustStrings(node.value, options); ++ } ++ ++ case "media-url": ++ { ++ return adjustStrings(node.value.replace(/^url\(\s+/gi, "url(").replace(/\s+\)$/gi, ")"), options); ++ } ++ ++ case "media-unknown": ++ { ++ return node.value; ++ } ++ // postcss-selector-parser ++ ++ case "selector-root": ++ { ++ return group$6(concat$9([insideAtRuleNode$1(path, "custom-selector") ? concat$9([getAncestorNode$1(path, "css-atrule").customSelector, line$5]) : "", join$6(concat$9([",", insideAtRuleNode$1(path, ["extend", "custom-selector", "nest"]) ? line$5 : hardline$7]), path.map(print, "nodes"))])); ++ } ++ ++ case "selector-selector": ++ { ++ return group$6(indent$5(concat$9(path.map(print, "nodes")))); ++ } ++ ++ case "selector-comment": ++ { ++ return node.value; ++ } ++ ++ case "selector-string": ++ { ++ return adjustStrings(node.value, options); ++ } ++ ++ case "selector-tag": ++ { ++ const parentNode = path.getParentNode(); ++ const index = parentNode && parentNode.nodes.indexOf(node); ++ const prevNode = index && parentNode.nodes[index - 1]; ++ return concat$9([node.namespace ? concat$9([node.namespace === true ? "" : node.namespace.trim(), "|"]) : "", prevNode.type === "selector-nesting" ? node.value : adjustNumbers(isKeyframeAtRuleKeywords$1(path, node.value) ? node.value.toLowerCase() : node.value)]); ++ } ++ ++ case "selector-id": ++ { ++ return concat$9(["#", node.value]); ++ } ++ ++ case "selector-class": ++ { ++ return concat$9([".", adjustNumbers(adjustStrings(node.value, options))]); ++ } ++ ++ case "selector-attribute": ++ { ++ return concat$9(["[", node.namespace ? concat$9([node.namespace === true ? "" : node.namespace.trim(), "|"]) : "", node.attribute.trim(), node.operator ? node.operator : "", node.value ? quoteAttributeValue(adjustStrings(node.value.trim(), options), options) : "", node.insensitive ? " i" : "", "]"]); ++ } ++ ++ case "selector-combinator": ++ { ++ if (node.value === "+" || node.value === ">" || node.value === "~" || node.value === ">>>") { ++ const parentNode = path.getParentNode(); ++ const leading = parentNode.type === "selector-selector" && parentNode.nodes[0] === node ? "" : line$5; ++ return concat$9([leading, node.value, isLastNode$1(path, node) ? "" : " "]); ++ } ++ ++ const leading = node.value.trim().startsWith("(") ? line$5 : ""; ++ const value = adjustNumbers(adjustStrings(node.value.trim(), options)) || line$5; ++ return concat$9([leading, value]); ++ } ++ ++ case "selector-universal": ++ { ++ return concat$9([node.namespace ? concat$9([node.namespace === true ? "" : node.namespace.trim(), "|"]) : "", node.value]); ++ } ++ ++ case "selector-pseudo": ++ { ++ return concat$9([maybeToLowerCase$1(node.value), node.nodes && node.nodes.length > 0 ? concat$9(["(", join$6(", ", path.map(print, "nodes")), ")"]) : ""]); ++ } ++ ++ case "selector-nesting": ++ { ++ return node.value; ++ } ++ ++ case "selector-unknown": ++ { ++ const ruleAncestorNode = getAncestorNode$1(path, "css-rule"); // Nested SCSS property ++ ++ if (ruleAncestorNode && ruleAncestorNode.isSCSSNesterProperty) { ++ return adjustNumbers(adjustStrings(maybeToLowerCase$1(node.value), options)); ++ } // originalText has to be used for Less, see replaceQuotesInInlineComments in loc.js ++ ++ ++ const parentNode = path.getParentNode(); ++ ++ if (parentNode.raws && parentNode.raws.selector) { ++ const start = options.locStart(parentNode); ++ const end = start + parentNode.raws.selector.length; ++ return options.originalText.slice(start, end).trim(); ++ } ++ ++ return node.value; ++ } ++ // postcss-values-parser ++ ++ case "value-value": ++ case "value-root": ++ { ++ return path.call(print, "group"); ++ } ++ ++ case "value-comment": ++ { ++ return concat$9([node.inline ? "//" : "/*", // see replaceQuotesInInlineComments in loc.js ++ // value-* nodes don't have correct location data, so we have to rely on placeholder characters. ++ restoreQuotesInInlineComments$1(node.value), node.inline ? "" : "*/"]); ++ } ++ ++ case "value-comma_group": ++ { ++ const parentNode = path.getParentNode(); ++ const parentParentNode = path.getParentNode(1); ++ const declAncestorProp = getPropOfDeclNode$1(path); ++ const isGridValue = declAncestorProp && parentNode.type === "value-value" && (declAncestorProp === "grid" || declAncestorProp.startsWith("grid-template")); ++ const atRuleAncestorNode = getAncestorNode$1(path, "css-atrule"); ++ const isControlDirective = atRuleAncestorNode && isSCSSControlDirectiveNode$1(atRuleAncestorNode); ++ const printed = path.map(print, "groups"); ++ const parts = []; ++ const insideURLFunction = insideValueFunctionNode$1(path, "url"); ++ let insideSCSSInterpolationInString = false; ++ let didBreak = false; ++ ++ for (let i = 0; i < node.groups.length; ++i) { ++ parts.push(printed[i]); ++ const iPrevNode = node.groups[i - 1]; ++ const iNode = node.groups[i]; ++ const iNextNode = node.groups[i + 1]; ++ const iNextNextNode = node.groups[i + 2]; ++ ++ if (insideURLFunction) { ++ if (iNextNode && isAdditionNode$1(iNextNode) || isAdditionNode$1(iNode)) { ++ parts.push(" "); ++ } ++ ++ continue; ++ } // Ignore after latest node (i.e. before semicolon) ++ ++ ++ if (!iNextNode) { ++ continue; ++ } // Ignore spaces before/after string interpolation (i.e. `"#{my-fn("_")}"`) ++ ++ ++ const isStartSCSSInterpolationInString = iNode.type === "value-string" && iNode.value.startsWith("#{"); ++ const isEndingSCSSInterpolationInString = insideSCSSInterpolationInString && iNextNode.type === "value-string" && iNextNode.value.endsWith("}"); ++ ++ if (isStartSCSSInterpolationInString || isEndingSCSSInterpolationInString) { ++ insideSCSSInterpolationInString = !insideSCSSInterpolationInString; ++ continue; ++ } ++ ++ if (insideSCSSInterpolationInString) { ++ continue; ++ } // Ignore colon (i.e. `:`) ++ ++ ++ if (isColonNode$1(iNode) || isColonNode$1(iNextNode)) { ++ continue; ++ } // Ignore `@` in Less (i.e. `@@var;`) ++ ++ ++ if (iNode.type === "value-atword" && iNode.value === "") { ++ continue; ++ } // Ignore `~` in Less (i.e. `content: ~"^//* some horrible but needed css hack";`) ++ ++ ++ if (iNode.value === "~") { ++ continue; ++ } // Ignore escape `\` ++ ++ ++ if (iNode.value && iNode.value.includes("\\") && iNextNode && iNextNode.type !== "value-comment") { ++ continue; ++ } // Ignore escaped `/` ++ ++ ++ if (iPrevNode && iPrevNode.value && iPrevNode.value.indexOf("\\") === iPrevNode.value.length - 1 && iNode.type === "value-operator" && iNode.value === "/") { ++ continue; ++ } // Ignore `\` (i.e. `$variable: \@small;`) ++ ++ ++ if (iNode.value === "\\") { ++ continue; ++ } // Ignore `$$` (i.e. `background-color: $$(style)Color;`) ++ ++ ++ if (isPostcssSimpleVarNode$1(iNode, iNextNode)) { ++ continue; ++ } // Ignore spaces after `#` and after `{` and before `}` in SCSS interpolation (i.e. `#{variable}`) ++ ++ ++ if (isHashNode$1(iNode) || isLeftCurlyBraceNode$1(iNode) || isRightCurlyBraceNode$1(iNextNode) || isLeftCurlyBraceNode$1(iNextNode) && hasEmptyRawBefore$1(iNextNode) || isRightCurlyBraceNode$1(iNode) && hasEmptyRawBefore$1(iNextNode)) { ++ continue; ++ } // Ignore css variables and interpolation in SCSS (i.e. `--#{$var}`) ++ ++ ++ if (iNode.value === "--" && isHashNode$1(iNextNode)) { ++ continue; ++ } // Formatting math operations ++ ++ ++ const isMathOperator = isMathOperatorNode$1(iNode); ++ const isNextMathOperator = isMathOperatorNode$1(iNextNode); // Print spaces before and after math operators beside SCSS interpolation as is ++ // (i.e. `#{$var}+5`, `#{$var} +5`, `#{$var}+ 5`, `#{$var} + 5`) ++ // (i.e. `5+#{$var}`, `5 +#{$var}`, `5+ #{$var}`, `5 + #{$var}`) ++ ++ if ((isMathOperator && isHashNode$1(iNextNode) || isNextMathOperator && isRightCurlyBraceNode$1(iNode)) && hasEmptyRawBefore$1(iNextNode)) { ++ continue; ++ } // Print spaces before and after addition and subtraction math operators as is in `calc` function ++ // due to the fact that it is not valid syntax ++ // (i.e. `calc(1px+1px)`, `calc(1px+ 1px)`, `calc(1px +1px)`, `calc(1px + 1px)`) ++ ++ ++ if (insideValueFunctionNode$1(path, "calc") && (isAdditionNode$1(iNode) || isAdditionNode$1(iNextNode) || isSubtractionNode$1(iNode) || isSubtractionNode$1(iNextNode)) && hasEmptyRawBefore$1(iNextNode)) { ++ continue; ++ } // Print spaces after `+` and `-` in color adjuster functions as is (e.g. `color(red l(+ 20%))`) ++ // Adjusters with signed numbers (e.g. `color(red l(+20%))`) output as-is. ++ ++ ++ const isColorAdjusterNode = (isAdditionNode$1(iNode) || isSubtractionNode$1(iNode)) && i === 0 && (iNextNode.type === "value-number" || iNextNode.isHex) && parentParentNode && isColorAdjusterFuncNode$1(parentParentNode) && !hasEmptyRawBefore$1(iNextNode); ++ const requireSpaceBeforeOperator = iNextNextNode && iNextNextNode.type === "value-func" || iNextNextNode && isWordNode$1(iNextNextNode) || iNode.type === "value-func" || isWordNode$1(iNode); ++ const requireSpaceAfterOperator = iNextNode.type === "value-func" || isWordNode$1(iNextNode) || iPrevNode && iPrevNode.type === "value-func" || iPrevNode && isWordNode$1(iPrevNode); // Formatting `/`, `+`, `-` sign ++ ++ if (!(isMultiplicationNode$1(iNextNode) || isMultiplicationNode$1(iNode)) && !insideValueFunctionNode$1(path, "calc") && !isColorAdjusterNode && (isDivisionNode$1(iNextNode) && !requireSpaceBeforeOperator || isDivisionNode$1(iNode) && !requireSpaceAfterOperator || isAdditionNode$1(iNextNode) && !requireSpaceBeforeOperator || isAdditionNode$1(iNode) && !requireSpaceAfterOperator || isSubtractionNode$1(iNextNode) || isSubtractionNode$1(iNode)) && (hasEmptyRawBefore$1(iNextNode) || isMathOperator && (!iPrevNode || iPrevNode && isMathOperatorNode$1(iPrevNode)))) { ++ continue; ++ } // Add `hardline` after inline comment (i.e. `// comment\n foo: bar;`) ++ ++ ++ if (isInlineValueCommentNode$1(iNode)) { ++ parts.push(hardline$7); ++ continue; ++ } // Handle keywords in SCSS control directive ++ ++ ++ if (isControlDirective && (isEqualityOperatorNode$1(iNextNode) || isRelationalOperatorNode$1(iNextNode) || isIfElseKeywordNode$1(iNextNode) || isEachKeywordNode$1(iNode) || isForKeywordNode$1(iNode))) { ++ parts.push(" "); ++ continue; ++ } // At-rule `namespace` should be in one line ++ ++ ++ if (atRuleAncestorNode && atRuleAncestorNode.name.toLowerCase() === "namespace") { ++ parts.push(" "); ++ continue; ++ } // Formatting `grid` property ++ ++ ++ if (isGridValue) { ++ if (iNode.source && iNextNode.source && iNode.source.start.line !== iNextNode.source.start.line) { ++ parts.push(hardline$7); ++ didBreak = true; ++ } else { ++ parts.push(" "); ++ } ++ ++ continue; ++ } // Add `space` before next math operation ++ // Note: `grip` property have `/` delimiter and it is not math operation, so ++ // `grid` property handles above ++ ++ ++ if (isNextMathOperator) { ++ parts.push(" "); ++ continue; ++ } // Be default all values go through `line` ++ ++ ++ parts.push(line$5); ++ } ++ ++ if (didBreak) { ++ parts.unshift(hardline$7); ++ } ++ ++ if (isControlDirective) { ++ return group$6(indent$5(concat$9(parts))); ++ } // Indent is not needed for import url when url is very long ++ // and node has two groups ++ // when type is value-comma_group ++ // example @import url("verylongurl") projection,tv ++ ++ ++ if (insideURLFunctionInImportAtRuleNode$1(path)) { ++ return group$6(fill$4(parts)); ++ } ++ ++ return group$6(indent$5(fill$4(parts))); ++ } ++ ++ case "value-paren_group": ++ { ++ const parentNode = path.getParentNode(); ++ ++ if (parentNode && isURLFunctionNode$1(parentNode) && (node.groups.length === 1 || node.groups.length > 0 && node.groups[0].type === "value-comma_group" && node.groups[0].groups.length > 0 && node.groups[0].groups[0].type === "value-word" && node.groups[0].groups[0].value.startsWith("data:"))) { ++ return concat$9([node.open ? path.call(print, "open") : "", join$6(",", path.map(print, "groups")), node.close ? path.call(print, "close") : ""]); ++ } ++ ++ if (!node.open) { ++ const printed = path.map(print, "groups"); ++ const res = []; ++ ++ for (let i = 0; i < printed.length; i++) { ++ if (i !== 0) { ++ res.push(concat$9([",", line$5])); ++ } ++ ++ res.push(printed[i]); ++ } ++ ++ return group$6(indent$5(fill$4(res))); ++ } ++ ++ const isSCSSMapItem = isSCSSMapItemNode$1(path); ++ const lastItem = node.groups[node.groups.length - 1]; ++ const isLastItemComment = lastItem && lastItem.type === "value-comment"; ++ return group$6(concat$9([node.open ? path.call(print, "open") : "", indent$5(concat$9([softline$3, join$6(concat$9([",", line$5]), path.map(childPath => { ++ const node = childPath.getValue(); ++ const printed = print(childPath); // Key/Value pair in open paren already indented ++ ++ if (isKeyValuePairNode$1(node) && node.type === "value-comma_group" && node.groups && node.groups[2] && node.groups[2].type === "value-paren_group") { ++ printed.contents.contents.parts[1] = group$6(printed.contents.contents.parts[1]); ++ return group$6(dedent$2(printed)); ++ } ++ ++ return printed; ++ }, "groups"))])), ifBreak$2(!isLastItemComment && isSCSS$1(options.parser, options.originalText) && isSCSSMapItem && shouldPrintComma$1(options) ? "," : ""), softline$3, node.close ? path.call(print, "close") : ""]), { ++ shouldBreak: isSCSSMapItem ++ }); ++ } ++ ++ case "value-func": ++ { ++ return concat$9([node.value, insideAtRuleNode$1(path, "supports") && isMediaAndSupportsKeywords$1(node) ? " " : "", path.call(print, "group")]); ++ } ++ ++ case "value-paren": ++ { ++ return node.value; ++ } ++ ++ case "value-number": ++ { ++ return concat$9([printCssNumber(node.value), maybeToLowerCase$1(node.unit)]); ++ } ++ ++ case "value-operator": ++ { ++ return node.value; ++ } ++ ++ case "value-word": ++ { ++ if (node.isColor && node.isHex || isWideKeywords$1(node.value)) { ++ return node.value.toLowerCase(); ++ } ++ ++ return node.value; ++ } ++ ++ case "value-colon": ++ { ++ return concat$9([node.value, // Don't add spaces on `:` in `url` function (i.e. `url(fbglyph: cross-outline, fig-white)`) ++ insideValueFunctionNode$1(path, "url") ? "" : line$5]); ++ } ++ ++ case "value-comma": ++ { ++ return concat$9([node.value, " "]); ++ } ++ ++ case "value-string": ++ { ++ return printString$2(node.raws.quote + node.value + node.raws.quote, options); ++ } ++ ++ case "value-atword": ++ { ++ return concat$9(["@", node.value]); ++ } ++ ++ case "value-unicode-range": ++ { ++ return node.value; ++ } ++ ++ case "value-unknown": ++ { ++ return node.value; ++ } ++ ++ default: ++ /* istanbul ignore next */ ++ throw new Error(`Unknown postcss type ${JSON.stringify(node.type)}`); ++ } ++} ++ ++function printNodeSequence(path, options, print) { ++ const node = path.getValue(); ++ const parts = []; ++ let i = 0; ++ path.map(pathChild => { ++ const prevNode = node.nodes[i - 1]; ++ ++ if (prevNode && prevNode.type === "css-comment" && prevNode.text.trim() === "prettier-ignore") { ++ const childNode = pathChild.getValue(); ++ parts.push(options.originalText.slice(options.locStart(childNode), options.locEnd(childNode))); ++ } else { ++ parts.push(pathChild.call(print)); ++ } ++ ++ if (i !== node.nodes.length - 1) { ++ if (node.nodes[i + 1].type === "css-comment" && !hasNewline$5(options.originalText, options.locStart(node.nodes[i + 1]), { ++ backwards: true ++ }) && node.nodes[i].type !== "yaml" && node.nodes[i].type !== "toml" || node.nodes[i + 1].type === "css-atrule" && node.nodes[i + 1].name === "else" && node.nodes[i].type !== "css-comment") { ++ parts.push(" "); ++ } else { ++ parts.push(options.__isHTMLStyleAttribute ? line$5 : hardline$7); ++ ++ if (isNextLineEmpty$3(options.originalText, pathChild.getValue(), options.locEnd) && node.nodes[i].type !== "yaml" && node.nodes[i].type !== "toml") { ++ parts.push(hardline$7); ++ } ++ } ++ } ++ ++ i++; ++ }, "nodes"); ++ return concat$9(parts); ++} ++ ++const STRING_REGEX$3 = /(['"])(?:(?!\1)[^\\]|\\[\s\S])*\1/g; ++const NUMBER_REGEX = /(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g; ++const STANDARD_UNIT_REGEX = /[a-zA-Z]+/g; ++const WORD_PART_REGEX = /[$@]?[a-zA-Z_\u0080-\uFFFF][\w\-\u0080-\uFFFF]*/g; ++const ADJUST_NUMBERS_REGEX = new RegExp(STRING_REGEX$3.source + "|" + `(${WORD_PART_REGEX.source})?` + `(${NUMBER_REGEX.source})` + `(${STANDARD_UNIT_REGEX.source})?`, "g"); ++ ++function adjustStrings(value, options) { ++ return value.replace(STRING_REGEX$3, match => printString$2(match, options)); ++} ++ ++function quoteAttributeValue(value, options) { ++ const quote = options.singleQuote ? "'" : '"'; ++ return value.includes('"') || value.includes("'") ? value : quote + value + quote; ++} ++ ++function adjustNumbers(value) { ++ return value.replace(ADJUST_NUMBERS_REGEX, (match, quote, wordPart, number, unit) => !wordPart && number ? printCssNumber(number) + maybeToLowerCase$1(unit || "") : match); ++} ++ ++function printCssNumber(rawNumber) { ++ return printNumber$2(rawNumber) // Remove trailing `.0`. ++ .replace(/\.0(?=$|e)/, ""); ++} ++ ++var printerPostcss = { ++ print: genericPrint$2, ++ embed: embed_1$1, ++ insertPragma: insertPragma$3, ++ hasPrettierIgnore: hasIgnoreComment$3, ++ massageAstNode: clean_1$1 ++}; ++ ++var options$3 = { ++ singleQuote: commonOptions.singleQuote ++}; ++ ++var name$9 = "CSS"; ++var type$7 = "markup"; ++var tmScope$7 = "source.css"; ++var aceMode$7 = "css"; ++var codemirrorMode$7 = "css"; ++var codemirrorMimeType$7 = "text/css"; ++var color$2 = "#563d7c"; ++var extensions$7 = [ ++ ".css" ++]; ++var languageId$7 = 50; ++var CSS = { ++ name: name$9, ++ type: type$7, ++ tmScope: tmScope$7, ++ aceMode: aceMode$7, ++ codemirrorMode: codemirrorMode$7, ++ codemirrorMimeType: codemirrorMimeType$7, ++ color: color$2, ++ extensions: extensions$7, ++ languageId: languageId$7 ++}; ++ ++var CSS$1 = /*#__PURE__*/Object.freeze({ ++ __proto__: null, ++ name: name$9, ++ type: type$7, ++ tmScope: tmScope$7, ++ aceMode: aceMode$7, ++ codemirrorMode: codemirrorMode$7, ++ codemirrorMimeType: codemirrorMimeType$7, ++ color: color$2, ++ extensions: extensions$7, ++ languageId: languageId$7, ++ 'default': CSS ++}); ++ ++var name$a = "PostCSS"; ++var type$8 = "markup"; ++var tmScope$8 = "source.postcss"; ++var group$7 = "CSS"; ++var extensions$8 = [ ++ ".pcss", ++ ".postcss" ++]; ++var aceMode$8 = "text"; ++var languageId$8 = 262764437; ++var PostCSS = { ++ name: name$a, ++ type: type$8, ++ tmScope: tmScope$8, ++ group: group$7, ++ extensions: extensions$8, ++ aceMode: aceMode$8, ++ languageId: languageId$8 ++}; ++ ++var PostCSS$1 = /*#__PURE__*/Object.freeze({ ++ __proto__: null, ++ name: name$a, ++ type: type$8, ++ tmScope: tmScope$8, ++ group: group$7, ++ extensions: extensions$8, ++ aceMode: aceMode$8, ++ languageId: languageId$8, ++ 'default': PostCSS ++}); ++ ++var name$b = "Less"; ++var type$9 = "markup"; ++var group$8 = "CSS"; ++var extensions$9 = [ ++ ".less" ++]; ++var tmScope$9 = "source.css.less"; ++var aceMode$9 = "less"; ++var codemirrorMode$8 = "css"; ++var codemirrorMimeType$8 = "text/css"; ++var languageId$9 = 198; ++var Less = { ++ name: name$b, ++ type: type$9, ++ group: group$8, ++ extensions: extensions$9, ++ tmScope: tmScope$9, ++ aceMode: aceMode$9, ++ codemirrorMode: codemirrorMode$8, ++ codemirrorMimeType: codemirrorMimeType$8, ++ languageId: languageId$9 ++}; ++ ++var Less$1 = /*#__PURE__*/Object.freeze({ ++ __proto__: null, ++ name: name$b, ++ type: type$9, ++ group: group$8, ++ extensions: extensions$9, ++ tmScope: tmScope$9, ++ aceMode: aceMode$9, ++ codemirrorMode: codemirrorMode$8, ++ codemirrorMimeType: codemirrorMimeType$8, ++ languageId: languageId$9, ++ 'default': Less ++}); ++ ++var name$c = "SCSS"; ++var type$a = "markup"; ++var tmScope$a = "source.css.scss"; ++var group$9 = "CSS"; ++var aceMode$a = "scss"; ++var codemirrorMode$9 = "css"; ++var codemirrorMimeType$9 = "text/x-scss"; ++var extensions$a = [ ++ ".scss" ++]; ++var languageId$a = 329; ++var SCSS = { ++ name: name$c, ++ type: type$a, ++ tmScope: tmScope$a, ++ group: group$9, ++ aceMode: aceMode$a, ++ codemirrorMode: codemirrorMode$9, ++ codemirrorMimeType: codemirrorMimeType$9, ++ extensions: extensions$a, ++ languageId: languageId$a ++}; ++ ++var SCSS$1 = /*#__PURE__*/Object.freeze({ ++ __proto__: null, ++ name: name$c, ++ type: type$a, ++ tmScope: tmScope$a, ++ group: group$9, ++ aceMode: aceMode$a, ++ codemirrorMode: codemirrorMode$9, ++ codemirrorMimeType: codemirrorMimeType$9, ++ extensions: extensions$a, ++ languageId: languageId$a, ++ 'default': SCSS ++}); ++ ++var require$$0$2 = getCjsExportFromNamespace(CSS$1); ++ ++var require$$1$2 = getCjsExportFromNamespace(PostCSS$1); ++ ++var require$$2$1 = getCjsExportFromNamespace(Less$1); ++ ++var require$$3$1 = getCjsExportFromNamespace(SCSS$1); ++ ++const languages$1 = [createLanguage(require$$0$2, () => ({ ++ since: "1.4.0", ++ parsers: ["css"], ++ vscodeLanguageIds: ["css"] ++})), createLanguage(require$$1$2, () => ({ ++ since: "1.4.0", ++ parsers: ["css"], ++ vscodeLanguageIds: ["postcss"] ++})), createLanguage(require$$2$1, () => ({ ++ since: "1.4.0", ++ parsers: ["less"], ++ vscodeLanguageIds: ["less"] ++})), createLanguage(require$$3$1, () => ({ ++ since: "1.4.0", ++ parsers: ["scss"], ++ vscodeLanguageIds: ["scss"] ++}))]; ++const printers$1 = { ++ postcss: printerPostcss ++}; ++var languageCss = { ++ languages: languages$1, ++ options: options$3, ++ printers: printers$1 ++}; ++ ++var clean$3 = function (ast, newNode) { ++ delete newNode.loc; ++ delete newNode.selfClosing; // (Glimmer/HTML) ignore TextNode whitespace ++ ++ if (ast.type === "TextNode") { ++ const trimmed = ast.chars.trim(); ++ ++ if (!trimmed) { ++ return null; ++ } ++ ++ newNode.chars = trimmed; ++ } ++}; ++ ++function isUppercase(string) { ++ return string.toUpperCase() === string; ++} ++ ++function isGlimmerComponent(node) { ++ return isNodeOfSomeType(node, ["ElementNode"]) && typeof node.tag === "string" && (isUppercase(node.tag[0]) || node.tag.includes(".")); ++} ++ ++function isWhitespaceNode(node) { ++ return isNodeOfSomeType(node, ["TextNode"]) && !/\S/.test(node.chars); ++} ++ ++function isNodeOfSomeType(node, types) { ++ return node && types.some(type => node.type === type); ++} ++ ++function isParentOfSomeType(path, types) { ++ const parentNode = path.getParentNode(0); ++ return isNodeOfSomeType(parentNode, types); ++} ++ ++function isPreviousNodeOfSomeType(path, types) { ++ const previousNode = getPreviousNode(path); ++ return isNodeOfSomeType(previousNode, types); ++} ++ ++function isNextNodeOfSomeType(path, types) { ++ const nextNode = getNextNode(path); ++ return isNodeOfSomeType(nextNode, types); ++} ++ ++function getSiblingNode(path, offset) { ++ const node = path.getValue(); ++ const parentNode = path.getParentNode(0) || {}; ++ const children = parentNode.children || parentNode.body || []; ++ const index = children.indexOf(node); ++ return index !== -1 && children[index + offset]; ++} ++ ++function getPreviousNode(path, lookBack = 1) { ++ return getSiblingNode(path, -lookBack); ++} ++ ++function getNextNode(path) { ++ return getSiblingNode(path, 1); ++} ++ ++function isPrettierIgnoreNode(node) { ++ return isNodeOfSomeType(node, ["MustacheCommentStatement"]) && typeof node.value === "string" && node.value.trim() === "prettier-ignore"; ++} ++ ++function hasPrettierIgnore$2(path) { ++ const node = path.getValue(); ++ const previousPreviousNode = getPreviousNode(path, 2); ++ return isPrettierIgnoreNode(node) || isPrettierIgnoreNode(previousPreviousNode); ++} ++ ++var utils$8 = { ++ getNextNode, ++ getPreviousNode, ++ hasPrettierIgnore: hasPrettierIgnore$2, ++ isGlimmerComponent, ++ isNextNodeOfSomeType, ++ isNodeOfSomeType, ++ isParentOfSomeType, ++ isPreviousNodeOfSomeType, ++ isWhitespaceNode ++}; ++ ++const { ++ concat: concat$a, ++ join: join$7, ++ softline: softline$4, ++ hardline: hardline$8, ++ line: line$6, ++ group: group$a, ++ indent: indent$6, ++ ifBreak: ifBreak$3 ++} = document.builders; ++const { ++ getNextNode: getNextNode$1, ++ getPreviousNode: getPreviousNode$1, ++ hasPrettierIgnore: hasPrettierIgnore$3, ++ isGlimmerComponent: isGlimmerComponent$1, ++ isNextNodeOfSomeType: isNextNodeOfSomeType$1, ++ isParentOfSomeType: isParentOfSomeType$1, ++ isPreviousNodeOfSomeType: isPreviousNodeOfSomeType$1, ++ isWhitespaceNode: isWhitespaceNode$1 ++} = utils$8; // http://w3c.github.io/html/single-page.html#void-elements ++ ++const voidTags = ["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"]; // Formatter based on @glimmerjs/syntax's built-in test formatter: ++// https://github.com/glimmerjs/glimmer-vm/blob/master/packages/%40glimmer/syntax/lib/generation/print.ts ++ ++function print(path, options, print) { ++ const n = path.getValue(); ++ /* istanbul ignore if*/ ++ ++ if (!n) { ++ return ""; ++ } ++ ++ if (hasPrettierIgnore$3(path)) { ++ const startOffset = locationToOffset(options.originalText, n.loc.start.line - 1, n.loc.start.column); ++ const endOffset = locationToOffset(options.originalText, n.loc.end.line - 1, n.loc.end.column); ++ const ignoredText = options.originalText.slice(startOffset, endOffset); ++ return ignoredText; ++ } ++ ++ switch (n.type) { ++ case "Block": ++ case "Program": ++ case "Template": ++ { ++ return group$a(concat$a(path.map(print, "body"))); ++ } ++ ++ case "ElementNode": ++ { ++ const hasChildren = n.children.length > 0; ++ const hasNonWhitespaceChildren = n.children.some(n => !isWhitespaceNode$1(n)); ++ const isVoid = isGlimmerComponent$1(n) && (!hasChildren || !hasNonWhitespaceChildren) || voidTags.includes(n.tag); ++ const closeTagForNoBreak = isVoid ? concat$a([" />", softline$4]) : ">"; ++ const closeTagForBreak = isVoid ? "/>" : ">"; ++ ++ const printParams = (path, print) => indent$6(concat$a([n.attributes.length ? line$6 : "", join$7(line$6, path.map(print, "attributes")), n.modifiers.length ? line$6 : "", join$7(line$6, path.map(print, "modifiers")), n.comments.length ? line$6 : "", join$7(line$6, path.map(print, "comments"))])); ++ ++ const nextNode = getNextNode$1(path); ++ return concat$a([group$a(concat$a(["<", n.tag, printParams(path, print), n.blockParams.length ? ` as |${n.blockParams.join(" ")}|` : "", ifBreak$3(softline$4, ""), ifBreak$3(closeTagForBreak, closeTagForNoBreak)])), !isVoid ? group$a(concat$a([hasNonWhitespaceChildren ? indent$6(printChildren(path, options, print)) : "", ifBreak$3(hasChildren ? hardline$8 : "", ""), concat$a([""])])) : "", nextNode && nextNode.type === "ElementNode" ? hardline$8 : ""]); ++ } ++ ++ case "BlockStatement": ++ { ++ const pp = path.getParentNode(1); ++ const isElseIf = pp && pp.inverse && pp.inverse.body.length === 1 && pp.inverse.body[0] === n && pp.inverse.body[0].path.parts[0] === "if"; ++ const hasElseIf = n.inverse && n.inverse.body.length === 1 && n.inverse.body[0].type === "BlockStatement" && n.inverse.body[0].path.parts[0] === "if"; ++ const indentElse = hasElseIf ? a => a : indent$6; ++ const inverseElseStatement = (n.inverseStrip.open ? "{{~" : "{{") + "else" + (n.inverseStrip.close ? "~}}" : "}}"); ++ ++ if (n.inverse) { ++ return concat$a([isElseIf ? concat$a([n.openStrip.open ? "{{~else " : "{{else ", printPathParams(path, print), n.openStrip.close ? "~}}" : "}}"]) : printOpenBlock(path, print, n.openStrip), indent$6(concat$a([hardline$8, path.call(print, "program")])), n.inverse && !hasElseIf ? concat$a([hardline$8, inverseElseStatement]) : "", n.inverse ? indentElse(concat$a([hardline$8, path.call(print, "inverse")])) : "", isElseIf ? "" : concat$a([hardline$8, printCloseBlock(path, print, n.closeStrip)])]); ++ } else if (isElseIf) { ++ return concat$a([concat$a([n.openStrip.open ? "{{~else" : "{{else ", printPathParams(path, print), n.openStrip.close ? "~}}" : "}}"]), indent$6(concat$a([hardline$8, path.call(print, "program")]))]); ++ } ++ ++ const hasNonWhitespaceChildren = n.program.body.some(n => !isWhitespaceNode$1(n)); ++ return concat$a([printOpenBlock(path, print, n.openStrip), group$a(concat$a([indent$6(concat$a([softline$4, path.call(print, "program")])), hasNonWhitespaceChildren ? hardline$8 : softline$4, printCloseBlock(path, print, n.closeStrip)]))]); ++ } ++ ++ case "ElementModifierStatement": ++ { ++ return group$a(concat$a(["{{", printPathParams(path, print), softline$4, "}}"])); ++ } ++ ++ case "MustacheStatement": ++ { ++ const isEscaped = n.escaped === false; ++ const { ++ open: openStrip, ++ close: closeStrip ++ } = n.strip; ++ const opening = (isEscaped ? "{{{" : "{{") + (openStrip ? "~" : ""); ++ const closing = (closeStrip ? "~" : "") + (isEscaped ? "}}}" : "}}"); ++ const leading = isParentOfSomeType$1(path, ["AttrNode", "ConcatStatement", "ElementNode"]) ? [opening, indent$6(softline$4)] : [opening]; ++ return group$a(concat$a([...leading, printPathParams(path, print), softline$4, closing])); ++ } ++ ++ case "SubExpression": ++ { ++ const params = printParams(path, print); ++ const printedParams = params.length > 0 ? indent$6(concat$a([line$6, group$a(join$7(line$6, params))])) : ""; ++ return group$a(concat$a(["(", printPath(path, print), printedParams, softline$4, ")"])); ++ } ++ ++ case "AttrNode": ++ { ++ const isText = n.value.type === "TextNode"; ++ const isEmptyText = isText && n.value.chars === ""; // If the text is empty and the value's loc start and end columns are the ++ // same, there is no value for this AttrNode and it should be printed ++ // without the `=""`. Example: `` -> `` ++ ++ const isEmptyValue = isEmptyText && n.value.loc.start.column === n.value.loc.end.column; ++ ++ if (isEmptyValue) { ++ return concat$a([n.name]); ++ } ++ ++ const value = path.call(print, "value"); ++ const quotedValue = isText ? printStringLiteral(value.parts.join(), options) : value; ++ return concat$a([n.name, "=", quotedValue]); ++ } ++ ++ case "ConcatStatement": ++ { ++ return concat$a(['"', concat$a(path.map(partPath => print(partPath), "parts").filter(a => a !== "")), '"']); ++ } ++ ++ case "Hash": ++ { ++ return concat$a([join$7(line$6, path.map(print, "pairs"))]); ++ } ++ ++ case "HashPair": ++ { ++ return concat$a([n.key, "=", path.call(print, "value")]); ++ } ++ ++ case "TextNode": ++ { ++ const maxLineBreaksToPreserve = 2; ++ const isFirstElement = !getPreviousNode$1(path); ++ const isLastElement = !getNextNode$1(path); ++ const isWhitespaceOnly = !/\S/.test(n.chars); ++ const lineBreaksCount = countNewLines(n.chars); ++ const hasBlockParent = path.getParentNode(0).type === "Block"; ++ const hasElementParent = path.getParentNode(0).type === "ElementNode"; ++ const hasTemplateParent = path.getParentNode(0).type === "Template"; ++ let leadingLineBreaksCount = countLeadingNewLines(n.chars); ++ let trailingLineBreaksCount = countTrailingNewLines(n.chars); ++ ++ if ((isFirstElement || isLastElement) && isWhitespaceOnly && (hasBlockParent || hasElementParent || hasTemplateParent)) { ++ return ""; ++ } ++ ++ if (isWhitespaceOnly && lineBreaksCount) { ++ leadingLineBreaksCount = Math.min(lineBreaksCount, maxLineBreaksToPreserve); ++ trailingLineBreaksCount = 0; ++ } else { ++ if (isNextNodeOfSomeType$1(path, ["BlockStatement", "ElementNode"])) { ++ trailingLineBreaksCount = Math.max(trailingLineBreaksCount, 1); ++ } ++ ++ if (isPreviousNodeOfSomeType$1(path, ["ElementNode"]) || isPreviousNodeOfSomeType$1(path, ["BlockStatement"])) { ++ leadingLineBreaksCount = Math.max(leadingLineBreaksCount, 1); ++ } ++ } ++ ++ let leadingSpace = ""; ++ let trailingSpace = ""; // preserve a space inside of an attribute node where whitespace present, ++ // when next to mustache statement. ++ ++ const inAttrNode = path.stack.includes("attributes"); ++ ++ if (inAttrNode) { ++ const parentNode = path.getParentNode(0); ++ const isConcat = parentNode.type === "ConcatStatement"; ++ ++ if (isConcat) { ++ const { ++ parts ++ } = parentNode; ++ const partIndex = parts.indexOf(n); ++ ++ if (partIndex > 0) { ++ const partType = parts[partIndex - 1].type; ++ const isMustache = partType === "MustacheStatement"; ++ ++ if (isMustache) { ++ leadingSpace = " "; ++ } ++ } ++ ++ if (partIndex < parts.length - 1) { ++ const partType = parts[partIndex + 1].type; ++ const isMustache = partType === "MustacheStatement"; ++ ++ if (isMustache) { ++ trailingSpace = " "; ++ } ++ } ++ } ++ } else { ++ if (trailingLineBreaksCount === 0 && isNextNodeOfSomeType$1(path, ["MustacheStatement"])) { ++ trailingSpace = " "; ++ } ++ ++ if (leadingLineBreaksCount === 0 && isPreviousNodeOfSomeType$1(path, ["MustacheStatement"])) { ++ leadingSpace = " "; ++ } ++ ++ if (isFirstElement) { ++ leadingLineBreaksCount = 0; ++ leadingSpace = ""; ++ } ++ ++ if (isLastElement) { ++ trailingLineBreaksCount = 0; ++ trailingSpace = ""; ++ } ++ } ++ ++ return concat$a([...generateHardlines(leadingLineBreaksCount, maxLineBreaksToPreserve), n.chars.replace(/^[\s ]+/g, leadingSpace).replace(/[\s ]+$/, trailingSpace), ...generateHardlines(trailingLineBreaksCount, maxLineBreaksToPreserve)].filter(Boolean)); ++ } ++ ++ case "MustacheCommentStatement": ++ { ++ const dashes = n.value.includes("}}") ? "--" : ""; ++ return concat$a(["{{!", dashes, n.value, dashes, "}}"]); ++ } ++ ++ case "PathExpression": ++ { ++ return n.original; ++ } ++ ++ case "BooleanLiteral": ++ { ++ return String(n.value); ++ } ++ ++ case "CommentStatement": ++ { ++ return concat$a([""]); ++ } ++ ++ case "StringLiteral": ++ { ++ return printStringLiteral(n.value, options); ++ } ++ ++ case "NumberLiteral": ++ { ++ return String(n.value); ++ } ++ ++ case "UndefinedLiteral": ++ { ++ return "undefined"; ++ } ++ ++ case "NullLiteral": ++ { ++ return "null"; ++ } ++ ++ /* istanbul ignore next */ ++ ++ default: ++ throw new Error("unknown glimmer type: " + JSON.stringify(n.type)); ++ } ++} ++ ++function printChildren(path, options, print) { ++ return concat$a(path.map((childPath, childIndex) => { ++ const childNode = path.getValue(); ++ const isFirstNode = childIndex === 0; ++ const isLastNode = childIndex === path.getParentNode(0).children.length - 1; ++ const isLastNodeInMultiNodeList = isLastNode && !isFirstNode; ++ const isWhitespace = isWhitespaceNode$1(childNode); ++ ++ if (isWhitespace && isLastNodeInMultiNodeList) { ++ return print(childPath, options, print); ++ } else if (isFirstNode) { ++ return concat$a([softline$4, print(childPath, options, print)]); ++ } ++ ++ return print(childPath, options, print); ++ }, "children")); ++} ++/** ++ * Prints a string literal with the correct surrounding quotes based on ++ * `options.singleQuote` and the number of escaped quotes contained in ++ * the string literal. This function is the glimmer equivalent of `printString` ++ * in `common/util`, but has differences because of the way escaped characters ++ * are treated in hbs string literals. ++ * @param {string} stringLiteral - the string literal value ++ * @param {object} options - the prettier options object ++ */ ++ ++ ++function printStringLiteral(stringLiteral, options) { ++ const double = { ++ quote: '"', ++ regex: /"/g ++ }; ++ const single = { ++ quote: "'", ++ regex: /'/g ++ }; ++ const preferred = options.singleQuote ? single : double; ++ const alternate = preferred === single ? double : single; ++ let shouldUseAlternateQuote = false; // If `stringLiteral` contains at least one of the quote preferred for ++ // enclosing the string, we might want to enclose with the alternate quote ++ // instead, to minimize the number of escaped quotes. ++ ++ if (stringLiteral.includes(preferred.quote) || stringLiteral.includes(alternate.quote)) { ++ const numPreferredQuotes = (stringLiteral.match(preferred.regex) || []).length; ++ const numAlternateQuotes = (stringLiteral.match(alternate.regex) || []).length; ++ shouldUseAlternateQuote = numPreferredQuotes > numAlternateQuotes; ++ } ++ ++ const enclosingQuote = shouldUseAlternateQuote ? alternate : preferred; ++ const escapedStringLiteral = stringLiteral.replace(enclosingQuote.regex, `\\${enclosingQuote.quote}`); ++ return concat$a([enclosingQuote.quote, escapedStringLiteral, enclosingQuote.quote]); ++} ++ ++function printPath(path, print) { ++ return path.call(print, "path"); ++} ++ ++function printParams(path, print) { ++ const node = path.getValue(); ++ let parts = []; ++ ++ if (node.params.length > 0) { ++ parts = parts.concat(path.map(print, "params")); ++ } ++ ++ if (node.hash && node.hash.pairs.length > 0) { ++ parts.push(path.call(print, "hash")); ++ } ++ ++ return parts; ++} ++ ++function printPathParams(path, print) { ++ const printedPath = printPath(path, print); ++ const printedParams = printParams(path, print); ++ const parts = [printedPath, ...printedParams]; ++ return indent$6(group$a(join$7(line$6, parts))); ++} ++ ++function printBlockParams(path) { ++ const block = path.getValue(); ++ ++ if (!block.program || !block.program.blockParams.length) { ++ return ""; ++ } ++ ++ return concat$a([" as |", block.program.blockParams.join(" "), "|"]); ++} ++ ++function printOpenBlock(path, print, { ++ open: isOpenStrip = false, ++ close: isCloseStrip = false ++} = {}) { ++ return group$a(concat$a([isOpenStrip ? "{{~#" : "{{#", printPathParams(path, print), printBlockParams(path), softline$4, isCloseStrip ? "~}}" : "}}"])); ++} ++ ++function printCloseBlock(path, print, { ++ open: isOpenStrip = false, ++ close: isCloseStrip = false ++} = {}) { ++ return concat$a([isOpenStrip ? "{{~/" : "{{/", path.call(print, "path"), isCloseStrip ? "~}}" : "}}"]); ++} ++ ++function countNewLines(string) { ++ /* istanbul ignore next */ ++ string = typeof string === "string" ? string : ""; ++ return string.split("\n").length - 1; ++} ++ ++function countLeadingNewLines(string) { ++ /* istanbul ignore next */ ++ string = typeof string === "string" ? string : ""; ++ const newLines = (string.match(/^([^\S\r\n]*[\r\n])+/g) || [])[0] || ""; ++ return countNewLines(newLines); ++} ++ ++function countTrailingNewLines(string) { ++ /* istanbul ignore next */ ++ string = typeof string === "string" ? string : ""; ++ const newLines = (string.match(/([\r\n][^\S\r\n]*)+$/g) || [])[0] || ""; ++ return countNewLines(newLines); ++} ++ ++function generateHardlines(number = 0, max = 0) { ++ return new Array(Math.min(number, max)).fill(hardline$8); ++} ++/* istanbul ignore next ++ https://github.com/glimmerjs/glimmer-vm/blob/master/packages/%40glimmer/compiler/lib/location.ts#L5-L29 ++*/ ++ ++ ++function locationToOffset(source, line, column) { ++ let seenLines = 0; ++ let seenChars = 0; // eslint-disable-next-line no-constant-condition ++ ++ while (true) { ++ if (seenChars === source.length) { ++ return null; ++ } ++ ++ let nextLine = source.indexOf("\n", seenChars); ++ ++ if (nextLine === -1) { ++ nextLine = source.length; ++ } ++ ++ if (seenLines === line) { ++ if (seenChars + column > nextLine) { ++ return null; ++ } ++ ++ return seenChars + column; ++ } else if (nextLine === -1) { ++ return null; ++ } ++ ++ seenLines += 1; ++ seenChars = nextLine + 1; ++ } ++} ++ ++var printerGlimmer = { ++ print, ++ massageAstNode: clean$3 ++}; ++ ++var name$d = "Handlebars"; ++var type$b = "markup"; ++var group$b = "HTML"; ++var aliases$3 = [ ++ "hbs", ++ "htmlbars" ++]; ++var extensions$b = [ ++ ".handlebars", ++ ".hbs" ++]; ++var tmScope$b = "text.html.handlebars"; ++var aceMode$b = "handlebars"; ++var languageId$b = 155; ++var Handlebars = { ++ name: name$d, ++ type: type$b, ++ group: group$b, ++ aliases: aliases$3, ++ extensions: extensions$b, ++ tmScope: tmScope$b, ++ aceMode: aceMode$b, ++ languageId: languageId$b ++}; ++ ++var Handlebars$1 = /*#__PURE__*/Object.freeze({ ++ __proto__: null, ++ name: name$d, ++ type: type$b, ++ group: group$b, ++ aliases: aliases$3, ++ extensions: extensions$b, ++ tmScope: tmScope$b, ++ aceMode: aceMode$b, ++ languageId: languageId$b, ++ 'default': Handlebars ++}); ++ ++var require$$0$3 = getCjsExportFromNamespace(Handlebars$1); ++ ++const languages$2 = [createLanguage(require$$0$3, () => ({ ++ since: null, ++ // unreleased ++ parsers: ["glimmer"], ++ vscodeLanguageIds: ["handlebars"] ++}))]; ++const printers$2 = { ++ glimmer: printerGlimmer ++}; ++var languageHandlebars = { ++ languages: languages$2, ++ printers: printers$2 ++}; ++ ++function hasPragma$2(text) { ++ return /^\s*#[^\n\S]*@(format|prettier)\s*(\n|$)/.test(text); ++} ++ ++function insertPragma$4(text) { ++ return "# @format\n\n" + text; ++} ++ ++var pragma$2 = { ++ hasPragma: hasPragma$2, ++ insertPragma: insertPragma$4 ++}; ++ ++const { ++ concat: concat$b, ++ join: join$8, ++ hardline: hardline$9, ++ line: line$7, ++ softline: softline$5, ++ group: group$c, ++ indent: indent$7, ++ ifBreak: ifBreak$4 ++} = document.builders; ++const { ++ hasIgnoreComment: hasIgnoreComment$4 ++} = util$1; ++const { ++ isNextLineEmpty: isNextLineEmpty$4 ++} = utilShared; ++const { ++ insertPragma: insertPragma$5 ++} = pragma$2; ++ ++function genericPrint$3(path, options, print) { ++ const n = path.getValue(); ++ ++ if (!n) { ++ return ""; ++ } ++ ++ if (typeof n === "string") { ++ return n; ++ } ++ ++ switch (n.kind) { ++ case "Document": ++ { ++ const parts = []; ++ path.map((pathChild, index) => { ++ parts.push(concat$b([pathChild.call(print)])); ++ ++ if (index !== n.definitions.length - 1) { ++ parts.push(hardline$9); ++ ++ if (isNextLineEmpty$4(options.originalText, pathChild.getValue(), options.locEnd)) { ++ parts.push(hardline$9); ++ } ++ } ++ }, "definitions"); ++ return concat$b([concat$b(parts), hardline$9]); ++ } ++ ++ case "OperationDefinition": ++ { ++ const hasOperation = options.originalText[options.locStart(n)] !== "{"; ++ const hasName = !!n.name; ++ return concat$b([hasOperation ? n.operation : "", hasOperation && hasName ? concat$b([" ", path.call(print, "name")]) : "", n.variableDefinitions && n.variableDefinitions.length ? group$c(concat$b(["(", indent$7(concat$b([softline$5, join$8(concat$b([ifBreak$4("", ", "), softline$5]), path.map(print, "variableDefinitions"))])), softline$5, ")"])) : "", printDirectives(path, print, n), n.selectionSet ? !hasOperation && !hasName ? "" : " " : "", path.call(print, "selectionSet")]); ++ } ++ ++ case "FragmentDefinition": ++ { ++ return concat$b(["fragment ", path.call(print, "name"), n.variableDefinitions && n.variableDefinitions.length ? group$c(concat$b(["(", indent$7(concat$b([softline$5, join$8(concat$b([ifBreak$4("", ", "), softline$5]), path.map(print, "variableDefinitions"))])), softline$5, ")"])) : "", " on ", path.call(print, "typeCondition"), printDirectives(path, print, n), " ", path.call(print, "selectionSet")]); ++ } ++ ++ case "SelectionSet": ++ { ++ return concat$b(["{", indent$7(concat$b([hardline$9, join$8(hardline$9, path.call(selectionsPath => printSequence(selectionsPath, options, print), "selections"))])), hardline$9, "}"]); ++ } ++ ++ case "Field": ++ { ++ return group$c(concat$b([n.alias ? concat$b([path.call(print, "alias"), ": "]) : "", path.call(print, "name"), n.arguments.length > 0 ? group$c(concat$b(["(", indent$7(concat$b([softline$5, join$8(concat$b([ifBreak$4("", ", "), softline$5]), path.call(argsPath => printSequence(argsPath, options, print), "arguments"))])), softline$5, ")"])) : "", printDirectives(path, print, n), n.selectionSet ? " " : "", path.call(print, "selectionSet")])); ++ } ++ ++ case "Name": ++ { ++ return n.value; ++ } ++ ++ case "StringValue": ++ { ++ if (n.block) { ++ return concat$b(['"""', hardline$9, join$8(hardline$9, n.value.replace(/"""/g, "\\$&").split("\n")), hardline$9, '"""']); ++ } ++ ++ return concat$b(['"', n.value.replace(/["\\]/g, "\\$&").replace(/\n/g, "\\n"), '"']); ++ } ++ ++ case "IntValue": ++ case "FloatValue": ++ case "EnumValue": ++ { ++ return n.value; ++ } ++ ++ case "BooleanValue": ++ { ++ return n.value ? "true" : "false"; ++ } ++ ++ case "NullValue": ++ { ++ return "null"; ++ } ++ ++ case "Variable": ++ { ++ return concat$b(["$", path.call(print, "name")]); ++ } ++ ++ case "ListValue": ++ { ++ return group$c(concat$b(["[", indent$7(concat$b([softline$5, join$8(concat$b([ifBreak$4("", ", "), softline$5]), path.map(print, "values"))])), softline$5, "]"])); ++ } ++ ++ case "ObjectValue": ++ { ++ return group$c(concat$b(["{", options.bracketSpacing && n.fields.length > 0 ? " " : "", indent$7(concat$b([softline$5, join$8(concat$b([ifBreak$4("", ", "), softline$5]), path.map(print, "fields"))])), softline$5, ifBreak$4("", options.bracketSpacing && n.fields.length > 0 ? " " : ""), "}"])); ++ } ++ ++ case "ObjectField": ++ case "Argument": ++ { ++ return concat$b([path.call(print, "name"), ": ", path.call(print, "value")]); ++ } ++ ++ case "Directive": ++ { ++ return concat$b(["@", path.call(print, "name"), n.arguments.length > 0 ? group$c(concat$b(["(", indent$7(concat$b([softline$5, join$8(concat$b([ifBreak$4("", ", "), softline$5]), path.call(argsPath => printSequence(argsPath, options, print), "arguments"))])), softline$5, ")"])) : ""]); ++ } ++ ++ case "NamedType": ++ { ++ return path.call(print, "name"); ++ } ++ ++ case "VariableDefinition": ++ { ++ return concat$b([path.call(print, "variable"), ": ", path.call(print, "type"), n.defaultValue ? concat$b([" = ", path.call(print, "defaultValue")]) : "", printDirectives(path, print, n)]); ++ } ++ ++ case "TypeExtensionDefinition": ++ { ++ return concat$b(["extend ", path.call(print, "definition")]); ++ } ++ ++ case "ObjectTypeExtension": ++ case "ObjectTypeDefinition": ++ { ++ return concat$b([path.call(print, "description"), n.description ? hardline$9 : "", n.kind === "ObjectTypeExtension" ? "extend " : "", "type ", path.call(print, "name"), n.interfaces.length > 0 ? concat$b([" implements ", concat$b(printInterfaces(path, options, print))]) : "", printDirectives(path, print, n), n.fields.length > 0 ? concat$b([" {", indent$7(concat$b([hardline$9, join$8(hardline$9, path.call(fieldsPath => printSequence(fieldsPath, options, print), "fields"))])), hardline$9, "}"]) : ""]); ++ } ++ ++ case "FieldDefinition": ++ { ++ return concat$b([path.call(print, "description"), n.description ? hardline$9 : "", path.call(print, "name"), n.arguments.length > 0 ? group$c(concat$b(["(", indent$7(concat$b([softline$5, join$8(concat$b([ifBreak$4("", ", "), softline$5]), path.call(argsPath => printSequence(argsPath, options, print), "arguments"))])), softline$5, ")"])) : "", ": ", path.call(print, "type"), printDirectives(path, print, n)]); ++ } ++ ++ case "DirectiveDefinition": ++ { ++ return concat$b([path.call(print, "description"), n.description ? hardline$9 : "", "directive ", "@", path.call(print, "name"), n.arguments.length > 0 ? group$c(concat$b(["(", indent$7(concat$b([softline$5, join$8(concat$b([ifBreak$4("", ", "), softline$5]), path.call(argsPath => printSequence(argsPath, options, print), "arguments"))])), softline$5, ")"])) : "", n.repeatable ? " repeatable" : "", concat$b([" on ", join$8(" | ", path.map(print, "locations"))])]); ++ } ++ ++ case "EnumTypeExtension": ++ case "EnumTypeDefinition": ++ { ++ return concat$b([path.call(print, "description"), n.description ? hardline$9 : "", n.kind === "EnumTypeExtension" ? "extend " : "", "enum ", path.call(print, "name"), printDirectives(path, print, n), n.values.length > 0 ? concat$b([" {", indent$7(concat$b([hardline$9, join$8(hardline$9, path.call(valuesPath => printSequence(valuesPath, options, print), "values"))])), hardline$9, "}"]) : ""]); ++ } ++ ++ case "EnumValueDefinition": ++ { ++ return concat$b([path.call(print, "description"), n.description ? hardline$9 : "", path.call(print, "name"), printDirectives(path, print, n)]); ++ } ++ ++ case "InputValueDefinition": ++ { ++ return concat$b([path.call(print, "description"), n.description ? n.description.block ? hardline$9 : line$7 : "", path.call(print, "name"), ": ", path.call(print, "type"), n.defaultValue ? concat$b([" = ", path.call(print, "defaultValue")]) : "", printDirectives(path, print, n)]); ++ } ++ ++ case "InputObjectTypeExtension": ++ case "InputObjectTypeDefinition": ++ { ++ return concat$b([path.call(print, "description"), n.description ? hardline$9 : "", n.kind === "InputObjectTypeExtension" ? "extend " : "", "input ", path.call(print, "name"), printDirectives(path, print, n), n.fields.length > 0 ? concat$b([" {", indent$7(concat$b([hardline$9, join$8(hardline$9, path.call(fieldsPath => printSequence(fieldsPath, options, print), "fields"))])), hardline$9, "}"]) : ""]); ++ } ++ ++ case "SchemaDefinition": ++ { ++ return concat$b(["schema", printDirectives(path, print, n), " {", n.operationTypes.length > 0 ? indent$7(concat$b([hardline$9, join$8(hardline$9, path.call(opsPath => printSequence(opsPath, options, print), "operationTypes"))])) : "", hardline$9, "}"]); ++ } ++ ++ case "OperationTypeDefinition": ++ { ++ return concat$b([path.call(print, "operation"), ": ", path.call(print, "type")]); ++ } ++ ++ case "InterfaceTypeExtension": ++ case "InterfaceTypeDefinition": ++ { ++ return concat$b([path.call(print, "description"), n.description ? hardline$9 : "", n.kind === "InterfaceTypeExtension" ? "extend " : "", "interface ", path.call(print, "name"), printDirectives(path, print, n), n.fields.length > 0 ? concat$b([" {", indent$7(concat$b([hardline$9, join$8(hardline$9, path.call(fieldsPath => printSequence(fieldsPath, options, print), "fields"))])), hardline$9, "}"]) : ""]); ++ } ++ ++ case "FragmentSpread": ++ { ++ return concat$b(["...", path.call(print, "name"), printDirectives(path, print, n)]); ++ } ++ ++ case "InlineFragment": ++ { ++ return concat$b(["...", n.typeCondition ? concat$b([" on ", path.call(print, "typeCondition")]) : "", printDirectives(path, print, n), " ", path.call(print, "selectionSet")]); ++ } ++ ++ case "UnionTypeExtension": ++ case "UnionTypeDefinition": ++ { ++ return group$c(concat$b([path.call(print, "description"), n.description ? hardline$9 : "", group$c(concat$b([n.kind === "UnionTypeExtension" ? "extend " : "", "union ", path.call(print, "name"), printDirectives(path, print, n), n.types.length > 0 ? concat$b([" =", ifBreak$4("", " "), indent$7(concat$b([ifBreak$4(concat$b([line$7, " "])), join$8(concat$b([line$7, "| "]), path.map(print, "types"))]))]) : ""]))])); ++ } ++ ++ case "ScalarTypeExtension": ++ case "ScalarTypeDefinition": ++ { ++ return concat$b([path.call(print, "description"), n.description ? hardline$9 : "", n.kind === "ScalarTypeExtension" ? "extend " : "", "scalar ", path.call(print, "name"), printDirectives(path, print, n)]); ++ } ++ ++ case "NonNullType": ++ { ++ return concat$b([path.call(print, "type"), "!"]); ++ } ++ ++ case "ListType": ++ { ++ return concat$b(["[", path.call(print, "type"), "]"]); ++ } ++ ++ default: ++ /* istanbul ignore next */ ++ throw new Error("unknown graphql type: " + JSON.stringify(n.kind)); ++ } ++} ++ ++function printDirectives(path, print, n) { ++ if (n.directives.length === 0) { ++ return ""; ++ } ++ ++ return concat$b([" ", group$c(indent$7(concat$b([softline$5, join$8(concat$b([ifBreak$4("", " "), softline$5]), path.map(print, "directives"))])))]); ++} ++ ++function printSequence(sequencePath, options, print) { ++ const count = sequencePath.getValue().length; ++ return sequencePath.map((path, i) => { ++ const printed = print(path); ++ ++ if (isNextLineEmpty$4(options.originalText, path.getValue(), options.locEnd) && i < count - 1) { ++ return concat$b([printed, hardline$9]); ++ } ++ ++ return printed; ++ }); ++} ++ ++function canAttachComment$1(node) { ++ return node.kind && node.kind !== "Comment"; ++} ++ ++function printComment$2(commentPath) { ++ const comment = commentPath.getValue(); ++ ++ if (comment.kind === "Comment") { ++ return "#" + comment.value.trimEnd(); ++ } ++ ++ throw new Error("Not a comment: " + JSON.stringify(comment)); ++} ++ ++function determineInterfaceSeparatorBetween(first, second, options) { ++ const textBetween = options.originalText.slice(first.loc.end, second.loc.start).replace(/#.*/g, "").trim(); ++ return textBetween === "," ? ", " : " & "; ++} ++ ++function printInterfaces(path, options, print) { ++ const node = path.getNode(); ++ const parts = []; ++ const { ++ interfaces ++ } = node; ++ const printed = path.map(node => print(node), "interfaces"); ++ ++ for (let index = 0; index < interfaces.length; index++) { ++ const interfaceNode = interfaces[index]; ++ ++ if (index > 0) { ++ parts.push(determineInterfaceSeparatorBetween(interfaces[index - 1], interfaceNode, options)); ++ } ++ ++ parts.push(printed[index]); ++ } ++ ++ return parts; ++} ++ ++function clean$4(node, newNode ++/*, parent*/ ++) { ++ delete newNode.loc; ++ delete newNode.comments; ++} ++ ++var printerGraphql = { ++ print: genericPrint$3, ++ massageAstNode: clean$4, ++ hasPrettierIgnore: hasIgnoreComment$4, ++ insertPragma: insertPragma$5, ++ printComment: printComment$2, ++ canAttachComment: canAttachComment$1 ++}; ++ ++var options$4 = { ++ bracketSpacing: commonOptions.bracketSpacing ++}; ++ ++var name$e = "GraphQL"; ++var type$c = "data"; ++var extensions$c = [ ++ ".graphql", ++ ".gql", ++ ".graphqls" ++]; ++var tmScope$c = "source.graphql"; ++var aceMode$c = "text"; ++var languageId$c = 139; ++var GraphQL = { ++ name: name$e, ++ type: type$c, ++ extensions: extensions$c, ++ tmScope: tmScope$c, ++ aceMode: aceMode$c, ++ languageId: languageId$c ++}; ++ ++var GraphQL$1 = /*#__PURE__*/Object.freeze({ ++ __proto__: null, ++ name: name$e, ++ type: type$c, ++ extensions: extensions$c, ++ tmScope: tmScope$c, ++ aceMode: aceMode$c, ++ languageId: languageId$c, ++ 'default': GraphQL ++}); ++ ++var require$$0$4 = getCjsExportFromNamespace(GraphQL$1); ++ ++const languages$3 = [createLanguage(require$$0$4, () => ({ ++ since: "1.5.0", ++ parsers: ["graphql"], ++ vscodeLanguageIds: ["graphql"] ++}))]; ++const printers$3 = { ++ graphql: printerGraphql ++}; ++var languageGraphql = { ++ languages: languages$3, ++ options: options$4, ++ printers: printers$3 ++}; ++ ++var json = { ++ "cjkPattern": "[\\u02ea-\\u02eb\\u1100-\\u11ff\\u2e80-\\u2e99\\u2e9b-\\u2ef3\\u2f00-\\u2fd5\\u3000-\\u303f\\u3041-\\u3096\\u3099-\\u309f\\u30a1-\\u30fa\\u30fc-\\u30ff\\u3105-\\u312f\\u3131-\\u318e\\u3190-\\u3191\\u3196-\\u31ba\\u31c0-\\u31e3\\u31f0-\\u321e\\u322a-\\u3247\\u3260-\\u327e\\u328a-\\u32b0\\u32c0-\\u32cb\\u32d0-\\u3370\\u337b-\\u337f\\u33e0-\\u33fe\\u3400-\\u4db5\\u4e00-\\u9fef\\ua960-\\ua97c\\uac00-\\ud7a3\\ud7b0-\\ud7c6\\ud7cb-\\ud7fb\\uf900-\\ufa6d\\ufa70-\\ufad9\\ufe10-\\ufe1f\\ufe30-\\ufe6f\\uff00-\\uffef]|[\\ud840-\\ud868\\ud86a-\\ud86c\\ud86f-\\ud872\\ud874-\\ud879][\\udc00-\\udfff]|\\ud82c[\\udc00-\\udd1e\\udd50-\\udd52\\udd64-\\udd67]|\\ud83c[\\ude00\\ude50-\\ude51]|\\ud869[\\udc00-\\uded6\\udf00-\\udfff]|\\ud86d[\\udc00-\\udf34\\udf40-\\udfff]|\\ud86e[\\udc00-\\udc1d\\udc20-\\udfff]|\\ud873[\\udc00-\\udea1\\udeb0-\\udfff]|\\ud87a[\\udc00-\\udfe0]|\\ud87e[\\udc00-\\ude1d]", ++ "kPattern": "[\\u1100-\\u11ff\\u3001-\\u3003\\u3008-\\u3011\\u3013-\\u301f\\u302e-\\u3030\\u3037\\u30fb\\u3131-\\u318e\\u3200-\\u321e\\u3260-\\u327e\\ua960-\\ua97c\\uac00-\\ud7a3\\ud7b0-\\ud7c6\\ud7cb-\\ud7fb\\ufe45-\\ufe46\\uff61-\\uff65\\uffa0-\\uffbe\\uffc2-\\uffc7\\uffca-\\uffcf\\uffd2-\\uffd7\\uffda-\\uffdc]", ++ "punctuationPattern": "[\\u0021-\\u002f\\u003a-\\u0040\\u005b-\\u0060\\u007b-\\u007e\\u00a1\\u00a7\\u00ab\\u00b6-\\u00b7\\u00bb\\u00bf\\u037e\\u0387\\u055a-\\u055f\\u0589-\\u058a\\u05be\\u05c0\\u05c3\\u05c6\\u05f3-\\u05f4\\u0609-\\u060a\\u060c-\\u060d\\u061b\\u061e-\\u061f\\u066a-\\u066d\\u06d4\\u0700-\\u070d\\u07f7-\\u07f9\\u0830-\\u083e\\u085e\\u0964-\\u0965\\u0970\\u09fd\\u0a76\\u0af0\\u0c77\\u0c84\\u0df4\\u0e4f\\u0e5a-\\u0e5b\\u0f04-\\u0f12\\u0f14\\u0f3a-\\u0f3d\\u0f85\\u0fd0-\\u0fd4\\u0fd9-\\u0fda\\u104a-\\u104f\\u10fb\\u1360-\\u1368\\u1400\\u166e\\u169b-\\u169c\\u16eb-\\u16ed\\u1735-\\u1736\\u17d4-\\u17d6\\u17d8-\\u17da\\u1800-\\u180a\\u1944-\\u1945\\u1a1e-\\u1a1f\\u1aa0-\\u1aa6\\u1aa8-\\u1aad\\u1b5a-\\u1b60\\u1bfc-\\u1bff\\u1c3b-\\u1c3f\\u1c7e-\\u1c7f\\u1cc0-\\u1cc7\\u1cd3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205e\\u207d-\\u207e\\u208d-\\u208e\\u2308-\\u230b\\u2329-\\u232a\\u2768-\\u2775\\u27c5-\\u27c6\\u27e6-\\u27ef\\u2983-\\u2998\\u29d8-\\u29db\\u29fc-\\u29fd\\u2cf9-\\u2cfc\\u2cfe-\\u2cff\\u2d70\\u2e00-\\u2e2e\\u2e30-\\u2e4f\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301f\\u3030\\u303d\\u30a0\\u30fb\\ua4fe-\\ua4ff\\ua60d-\\ua60f\\ua673\\ua67e\\ua6f2-\\ua6f7\\ua874-\\ua877\\ua8ce-\\ua8cf\\ua8f8-\\ua8fa\\ua8fc\\ua92e-\\ua92f\\ua95f\\ua9c1-\\ua9cd\\ua9de-\\ua9df\\uaa5c-\\uaa5f\\uaade-\\uaadf\\uaaf0-\\uaaf1\\uabeb\\ufd3e-\\ufd3f\\ufe10-\\ufe19\\ufe30-\\ufe52\\ufe54-\\ufe61\\ufe63\\ufe68\\ufe6a-\\ufe6b\\uff01-\\uff03\\uff05-\\uff0a\\uff0c-\\uff0f\\uff1a-\\uff1b\\uff1f-\\uff20\\uff3b-\\uff3d\\uff3f\\uff5b\\uff5d\\uff5f-\\uff65]|\\ud800[\\udd00-\\udd02\\udf9f\\udfd0]|\\ud801[\\udd6f]|\\ud802[\\udc57\\udd1f\\udd3f\\ude50-\\ude58\\ude7f\\udef0-\\udef6\\udf39-\\udf3f\\udf99-\\udf9c]|\\ud803[\\udf55-\\udf59]|\\ud804[\\udc47-\\udc4d\\udcbb-\\udcbc\\udcbe-\\udcc1\\udd40-\\udd43\\udd74-\\udd75\\uddc5-\\uddc8\\uddcd\\udddb\\udddd-\\udddf\\ude38-\\ude3d\\udea9]|\\ud805[\\udc4b-\\udc4f\\udc5b\\udc5d\\udcc6\\uddc1-\\uddd7\\ude41-\\ude43\\ude60-\\ude6c\\udf3c-\\udf3e]|\\ud806[\\udc3b\\udde2\\ude3f-\\ude46\\ude9a-\\ude9c\\ude9e-\\udea2]|\\ud807[\\udc41-\\udc45\\udc70-\\udc71\\udef7-\\udef8\\udfff]|\\ud809[\\udc70-\\udc74]|\\ud81a[\\ude6e-\\ude6f\\udef5\\udf37-\\udf3b\\udf44]|\\ud81b[\\ude97-\\ude9a\\udfe2]|\\ud82f[\\udc9f]|\\ud836[\\ude87-\\ude8b]|\\ud83a[\\udd5e-\\udd5f]" ++}; ++ ++const { ++ cjkPattern, ++ kPattern, ++ punctuationPattern ++} = json; ++const { ++ getLast: getLast$4 ++} = util$1; ++const INLINE_NODE_TYPES = ["liquidNode", "inlineCode", "emphasis", "strong", "delete", "link", "linkReference", "image", "imageReference", "footnote", "footnoteReference", "sentence", "whitespace", "word", "break", "inlineMath"]; ++const INLINE_NODE_WRAPPER_TYPES = INLINE_NODE_TYPES.concat(["tableCell", "paragraph", "heading"]); ++const kRegex = new RegExp(kPattern); ++const punctuationRegex = new RegExp(punctuationPattern); ++/** ++ * split text into whitespaces and words ++ * @param {string} text ++ * @return {Array<{ type: "whitespace", value: " " | "\n" | "" } | { type: "word", value: string }>} ++ */ ++ ++function splitText(text, options) { ++ const KIND_NON_CJK = "non-cjk"; ++ const KIND_CJ_LETTER = "cj-letter"; ++ const KIND_K_LETTER = "k-letter"; ++ const KIND_CJK_PUNCTUATION = "cjk-punctuation"; ++ const nodes = []; ++ (options.proseWrap === "preserve" ? text : text.replace(new RegExp(`(${cjkPattern})\n(${cjkPattern})`, "g"), "$1$2")).split(/([ \t\n]+)/).forEach((token, index, tokens) => { ++ // whitespace ++ if (index % 2 === 1) { ++ nodes.push({ ++ type: "whitespace", ++ value: /\n/.test(token) ? "\n" : " " ++ }); ++ return; ++ } // word separated by whitespace ++ ++ ++ if ((index === 0 || index === tokens.length - 1) && token === "") { ++ return; ++ } ++ ++ token.split(new RegExp(`(${cjkPattern})`)).forEach((innerToken, innerIndex, innerTokens) => { ++ if ((innerIndex === 0 || innerIndex === innerTokens.length - 1) && innerToken === "") { ++ return; ++ } // non-CJK word ++ ++ ++ if (innerIndex % 2 === 0) { ++ if (innerToken !== "") { ++ appendNode({ ++ type: "word", ++ value: innerToken, ++ kind: KIND_NON_CJK, ++ hasLeadingPunctuation: punctuationRegex.test(innerToken[0]), ++ hasTrailingPunctuation: punctuationRegex.test(getLast$4(innerToken)) ++ }); ++ } ++ ++ return; ++ } // CJK character ++ ++ ++ appendNode(punctuationRegex.test(innerToken) ? { ++ type: "word", ++ value: innerToken, ++ kind: KIND_CJK_PUNCTUATION, ++ hasLeadingPunctuation: true, ++ hasTrailingPunctuation: true ++ } : { ++ type: "word", ++ value: innerToken, ++ kind: kRegex.test(innerToken) ? KIND_K_LETTER : KIND_CJ_LETTER, ++ hasLeadingPunctuation: false, ++ hasTrailingPunctuation: false ++ }); ++ }); ++ }); ++ return nodes; ++ ++ function appendNode(node) { ++ const lastNode = getLast$4(nodes); ++ ++ if (lastNode && lastNode.type === "word") { ++ if (lastNode.kind === KIND_NON_CJK && node.kind === KIND_CJ_LETTER && !lastNode.hasTrailingPunctuation || lastNode.kind === KIND_CJ_LETTER && node.kind === KIND_NON_CJK && !node.hasLeadingPunctuation) { ++ nodes.push({ ++ type: "whitespace", ++ value: " " ++ }); ++ } else if (!isBetween(KIND_NON_CJK, KIND_CJK_PUNCTUATION) && // disallow leading/trailing full-width whitespace ++ ![lastNode.value, node.value].some(value => /\u3000/.test(value))) { ++ nodes.push({ ++ type: "whitespace", ++ value: "" ++ }); ++ } ++ } ++ ++ nodes.push(node); ++ ++ function isBetween(kind1, kind2) { ++ return lastNode.kind === kind1 && node.kind === kind2 || lastNode.kind === kind2 && node.kind === kind1; ++ } ++ } ++} ++ ++function getOrderedListItemInfo(orderListItem, originalText) { ++ const [, numberText, marker, leadingSpaces] = originalText.slice(orderListItem.position.start.offset, orderListItem.position.end.offset).match(/^\s*(\d+)(\.|\))(\s*)/); ++ return { ++ numberText, ++ marker, ++ leadingSpaces ++ }; ++} ++ ++function hasGitDiffFriendlyOrderedList(node, options) { ++ if (!node.ordered) { ++ return false; ++ } ++ ++ if (node.children.length < 2) { ++ return false; ++ } ++ ++ const firstNumber = Number(getOrderedListItemInfo(node.children[0], options.originalText).numberText); ++ const secondNumber = Number(getOrderedListItemInfo(node.children[1], options.originalText).numberText); ++ ++ if (firstNumber === 0 && node.children.length > 2) { ++ const thirdNumber = Number(getOrderedListItemInfo(node.children[2], options.originalText).numberText); ++ return secondNumber === 1 && thirdNumber === 1; ++ } ++ ++ return secondNumber === 1; ++} // workaround for https://github.com/remarkjs/remark/issues/351 ++// leading and trailing newlines are stripped by remark ++ ++ ++function getFencedCodeBlockValue(node, originalText) { ++ const text = originalText.slice(node.position.start.offset, node.position.end.offset); ++ const leadingSpaceCount = text.match(/^\s*/)[0].length; ++ const replaceRegex = new RegExp(`^\\s{0,${leadingSpaceCount}}`); ++ const lineContents = text.split("\n"); ++ const markerStyle = text[leadingSpaceCount]; // ` or ~ ++ ++ const marker = text.slice(leadingSpaceCount).match(new RegExp(`^[${markerStyle}]+`))[0]; // https://spec.commonmark.org/0.28/#example-104: Closing fences may be indented by 0-3 spaces ++ // https://spec.commonmark.org/0.28/#example-93: The closing code fence must be at least as long as the opening fence ++ ++ const hasEndMarker = new RegExp(`^\\s{0,3}${marker}`).test(lineContents[lineContents.length - 1].slice(getIndent(lineContents.length - 1))); ++ return lineContents.slice(1, hasEndMarker ? -1 : undefined).map((x, i) => x.slice(getIndent(i + 1)).replace(replaceRegex, "")).join("\n"); ++ ++ function getIndent(lineIndex) { ++ return node.position.indent[lineIndex - 1] - 1; ++ } ++} ++ ++function mapAst(ast, handler) { ++ return function preorder(node, index, parentStack) { ++ parentStack = parentStack || []; ++ const newNode = Object.assign({}, handler(node, index, parentStack)); ++ ++ if (newNode.children) { ++ newNode.children = newNode.children.map((child, index) => { ++ return preorder(child, index, [newNode].concat(parentStack)); ++ }); ++ } ++ ++ return newNode; ++ }(ast, null, null); ++} ++ ++var utils$9 = { ++ mapAst, ++ splitText, ++ punctuationPattern, ++ getFencedCodeBlockValue, ++ getOrderedListItemInfo, ++ hasGitDiffFriendlyOrderedList, ++ INLINE_NODE_TYPES, ++ INLINE_NODE_WRAPPER_TYPES ++}; ++ ++const { ++ builders: { ++ hardline: hardline$a, ++ literalline: literalline$4, ++ concat: concat$c, ++ markAsRoot: markAsRoot$2 ++ }, ++ utils: { ++ mapDoc: mapDoc$4 ++ } ++} = document; ++const { ++ getFencedCodeBlockValue: getFencedCodeBlockValue$1 ++} = utils$9; ++ ++function embed$2(path, print, textToDoc, options) { ++ const node = path.getValue(); ++ ++ if (node.type === "code" && node.lang !== null) { ++ // only look for the first string so as to support [markdown-preview-enhanced](https://shd101wyy.github.io/markdown-preview-enhanced/#/code-chunk) ++ const langMatch = node.lang.match(/^[A-Za-z0-9_-]+/); ++ const lang = langMatch ? langMatch[0] : ""; ++ const parser = getParserName(lang); ++ ++ if (parser) { ++ const styleUnit = options.__inJsTemplate ? "~" : "`"; ++ const style = styleUnit.repeat(Math.max(3, util$1.getMaxContinuousCount(node.value, styleUnit) + 1)); ++ const doc = textToDoc(getFencedCodeBlockValue$1(node, options.originalText), { ++ parser ++ }); ++ return markAsRoot$2(concat$c([style, node.lang, hardline$a, replaceNewlinesWithLiterallines(doc), style])); ++ } ++ } ++ ++ if (node.type === "yaml") { ++ return markAsRoot$2(concat$c(["---", hardline$a, node.value && node.value.trim() ? replaceNewlinesWithLiterallines(textToDoc(node.value, { ++ parser: "yaml" ++ })) : "", "---"])); ++ } // MDX ++ ++ ++ switch (node.type) { ++ case "importExport": ++ return textToDoc(node.value, { ++ parser: "babel" ++ }); ++ ++ case "jsx": ++ return textToDoc(`<$>${node.value}`, { ++ parser: "__js_expression", ++ rootMarker: "mdx" ++ }); ++ } ++ ++ return null; ++ ++ function getParserName(lang) { ++ const supportInfo = support.getSupportInfo({ ++ plugins: options.plugins ++ }); ++ const language = supportInfo.languages.find(language => language.name.toLowerCase() === lang || language.aliases && language.aliases.includes(lang) || language.extensions && language.extensions.find(ext => ext === `.${lang}`)); ++ ++ if (language) { ++ return language.parsers[0]; ++ } ++ ++ return null; ++ } ++ ++ function replaceNewlinesWithLiterallines(doc) { ++ return mapDoc$4(doc, currentDoc => typeof currentDoc === "string" && currentDoc.includes("\n") ? concat$c(currentDoc.split(/(\n)/g).map((v, i) => i % 2 === 0 ? v : literalline$4)) : currentDoc); ++ } ++} ++ ++var embed_1$2 = embed$2; ++ ++const pragmas = ["format", "prettier"]; ++ ++function startWithPragma(text) { ++ const pragma = `@(${pragmas.join("|")})`; ++ const regex = new RegExp([``, ``].join("|"), "m"); ++ const matched = text.match(regex); ++ return matched && matched.index === 0; ++} ++ ++var pragma$3 = { ++ startWithPragma, ++ hasPragma: text => startWithPragma(frontMatter(text).content.trimStart()), ++ insertPragma: text => { ++ const extracted = frontMatter(text); ++ const pragma = ``; ++ return extracted.frontMatter ? `${extracted.frontMatter.raw}\n\n${pragma}\n\n${extracted.content}` : `${pragma}\n\n${extracted.content}`; ++ } ++}; ++ ++const { ++ getOrderedListItemInfo: getOrderedListItemInfo$1, ++ mapAst: mapAst$1, ++ splitText: splitText$1 ++} = utils$9; // 0x0 ~ 0x10ffff ++// eslint-disable-next-line no-control-regex ++ ++const isSingleCharRegex = /^([\u0000-\uffff]|[\ud800-\udbff][\udc00-\udfff])$/; ++ ++function preprocess$1(ast, options) { ++ ast = restoreUnescapedCharacter(ast, options); ++ ast = mergeContinuousTexts(ast); ++ ast = transformInlineCode(ast); ++ ast = transformIndentedCodeblockAndMarkItsParentList(ast, options); ++ ast = markAlignedList(ast, options); ++ ast = splitTextIntoSentences(ast, options); ++ ast = transformImportExport(ast); ++ ast = mergeContinuousImportExport(ast); ++ return ast; ++} ++ ++function transformImportExport(ast) { ++ return mapAst$1(ast, node => { ++ if (node.type !== "import" && node.type !== "export") { ++ return node; ++ } ++ ++ return Object.assign({}, node, { ++ type: "importExport" ++ }); ++ }); ++} ++ ++function transformInlineCode(ast) { ++ return mapAst$1(ast, node => { ++ if (node.type !== "inlineCode") { ++ return node; ++ } ++ ++ return Object.assign({}, node, { ++ value: node.value.replace(/\s+/g, " ") ++ }); ++ }); ++} ++ ++function restoreUnescapedCharacter(ast, options) { ++ return mapAst$1(ast, node => { ++ return node.type !== "text" ? node : Object.assign({}, node, { ++ value: node.value !== "*" && node.value !== "_" && node.value !== "$" && // handle these cases in printer ++ isSingleCharRegex.test(node.value) && node.position.end.offset - node.position.start.offset !== node.value.length ? options.originalText.slice(node.position.start.offset, node.position.end.offset) : node.value ++ }); ++ }); ++} ++ ++function mergeContinuousImportExport(ast) { ++ return mergeChildren(ast, (prevNode, node) => prevNode.type === "importExport" && node.type === "importExport", (prevNode, node) => ({ ++ type: "importExport", ++ value: prevNode.value + "\n\n" + node.value, ++ position: { ++ start: prevNode.position.start, ++ end: node.position.end ++ } ++ })); ++} ++ ++function mergeChildren(ast, shouldMerge, mergeNode) { ++ return mapAst$1(ast, node => { ++ if (!node.children) { ++ return node; ++ } ++ ++ const children = node.children.reduce((current, child) => { ++ const lastChild = current[current.length - 1]; ++ ++ if (lastChild && shouldMerge(lastChild, child)) { ++ current.splice(-1, 1, mergeNode(lastChild, child)); ++ } else { ++ current.push(child); ++ } ++ ++ return current; ++ }, []); ++ return Object.assign({}, node, { ++ children ++ }); ++ }); ++} ++ ++function mergeContinuousTexts(ast) { ++ return mergeChildren(ast, (prevNode, node) => prevNode.type === "text" && node.type === "text", (prevNode, node) => ({ ++ type: "text", ++ value: prevNode.value + node.value, ++ position: { ++ start: prevNode.position.start, ++ end: node.position.end ++ } ++ })); ++} ++ ++function splitTextIntoSentences(ast, options) { ++ return mapAst$1(ast, (node, index, [parentNode]) => { ++ if (node.type !== "text") { ++ return node; ++ } ++ ++ let { ++ value ++ } = node; ++ ++ if (parentNode.type === "paragraph") { ++ if (index === 0) { ++ value = value.trimStart(); ++ } ++ ++ if (index === parentNode.children.length - 1) { ++ value = value.trimEnd(); ++ } ++ } ++ ++ return { ++ type: "sentence", ++ position: node.position, ++ children: splitText$1(value, options) ++ }; ++ }); ++} ++ ++function transformIndentedCodeblockAndMarkItsParentList(ast, options) { ++ return mapAst$1(ast, (node, index, parentStack) => { ++ if (node.type === "code") { ++ // the first char may point to `\n`, e.g. `\n\t\tbar`, just ignore it ++ const isIndented = /^\n?( {4,}|\t)/.test(options.originalText.slice(node.position.start.offset, node.position.end.offset)); ++ node.isIndented = isIndented; ++ ++ if (isIndented) { ++ for (let i = 0; i < parentStack.length; i++) { ++ const parent = parentStack[i]; // no need to check checked items ++ ++ if (parent.hasIndentedCodeblock) { ++ break; ++ } ++ ++ if (parent.type === "list") { ++ parent.hasIndentedCodeblock = true; ++ } ++ } ++ } ++ } ++ ++ return node; ++ }); ++} ++ ++function markAlignedList(ast, options) { ++ return mapAst$1(ast, (node, index, parentStack) => { ++ if (node.type === "list" && node.children.length !== 0) { ++ // if one of its parents is not aligned, it's not possible to be aligned in sub-lists ++ for (let i = 0; i < parentStack.length; i++) { ++ const parent = parentStack[i]; ++ ++ if (parent.type === "list" && !parent.isAligned) { ++ node.isAligned = false; ++ return node; ++ } ++ } ++ ++ node.isAligned = isAligned(node); ++ } ++ ++ return node; ++ }); ++ ++ function getListItemStart(listItem) { ++ return listItem.children.length === 0 ? -1 : listItem.children[0].position.start.column - 1; ++ } ++ ++ function isAligned(list) { ++ if (!list.ordered) { ++ /** ++ * - 123 ++ * - 123 ++ */ ++ return true; ++ } ++ ++ const [firstItem, secondItem] = list.children; ++ const firstInfo = getOrderedListItemInfo$1(firstItem, options.originalText); ++ ++ if (firstInfo.leadingSpaces.length > 1) { ++ /** ++ * 1. 123 ++ * ++ * 1. 123 ++ * 1. 123 ++ */ ++ return true; ++ } ++ ++ const firstStart = getListItemStart(firstItem); ++ ++ if (firstStart === -1) { ++ /** ++ * 1. ++ * ++ * 1. ++ * 1. ++ */ ++ return false; ++ } ++ ++ if (list.children.length === 1) { ++ /** ++ * aligned: ++ * ++ * 11. 123 ++ * ++ * not aligned: ++ * ++ * 1. 123 ++ */ ++ return firstStart % options.tabWidth === 0; ++ } ++ ++ const secondStart = getListItemStart(secondItem); ++ ++ if (firstStart !== secondStart) { ++ /** ++ * 11. 123 ++ * 1. 123 ++ * ++ * 1. 123 ++ * 11. 123 ++ */ ++ return false; ++ } ++ ++ if (firstStart % options.tabWidth === 0) { ++ /** ++ * 11. 123 ++ * 12. 123 ++ */ ++ return true; ++ } ++ /** ++ * aligned: ++ * ++ * 11. 123 ++ * 1. 123 ++ * ++ * not aligned: ++ * ++ * 1. 123 ++ * 2. 123 ++ */ ++ ++ ++ const secondInfo = getOrderedListItemInfo$1(secondItem, options.originalText); ++ return secondInfo.leadingSpaces.length > 1; ++ } ++} ++ ++var preprocess_1$1 = preprocess$1; ++ ++const { ++ builders: { ++ breakParent: breakParent$3, ++ concat: concat$d, ++ join: join$9, ++ line: line$8, ++ literalline: literalline$5, ++ markAsRoot: markAsRoot$3, ++ hardline: hardline$b, ++ softline: softline$6, ++ ifBreak: ifBreak$5, ++ fill: fill$5, ++ align: align$2, ++ indent: indent$8, ++ group: group$d ++ }, ++ utils: { ++ mapDoc: mapDoc$5 ++ }, ++ printer: { ++ printDocToString: printDocToString$3 ++ } ++} = document; ++const { ++ getFencedCodeBlockValue: getFencedCodeBlockValue$2, ++ hasGitDiffFriendlyOrderedList: hasGitDiffFriendlyOrderedList$1, ++ splitText: splitText$2, ++ punctuationPattern: punctuationPattern$1, ++ INLINE_NODE_TYPES: INLINE_NODE_TYPES$1, ++ INLINE_NODE_WRAPPER_TYPES: INLINE_NODE_WRAPPER_TYPES$1 ++} = utils$9; ++const { ++ replaceEndOfLineWith: replaceEndOfLineWith$1 ++} = util$1; ++const TRAILING_HARDLINE_NODES = ["importExport"]; ++const SINGLE_LINE_NODE_TYPES = ["heading", "tableCell", "link"]; ++const SIBLING_NODE_TYPES = ["listItem", "definition", "footnoteDefinition"]; ++ ++function genericPrint$4(path, options, print) { ++ const node = path.getValue(); ++ ++ if (shouldRemainTheSameContent(path)) { ++ return concat$d(splitText$2(options.originalText.slice(node.position.start.offset, node.position.end.offset), options).map(node => node.type === "word" ? node.value : node.value === "" ? "" : printLine(path, node.value, options))); ++ } ++ ++ switch (node.type) { ++ case "root": ++ if (node.children.length === 0) { ++ return ""; ++ } ++ ++ return concat$d([normalizeDoc(printRoot(path, options, print)), !TRAILING_HARDLINE_NODES.includes(getLastDescendantNode(node).type) ? hardline$b : ""]); ++ ++ case "paragraph": ++ return printChildren$1(path, options, print, { ++ postprocessor: fill$5 ++ }); ++ ++ case "sentence": ++ return printChildren$1(path, options, print); ++ ++ case "word": ++ return node.value.replace(/[*$]/g, "\\$&") // escape all `*` and `$` (math) ++ .replace(new RegExp([`(^|${punctuationPattern$1})(_+)`, `(_+)(${punctuationPattern$1}|$)`].join("|"), "g"), (_, text1, underscore1, underscore2, text2) => (underscore1 ? `${text1}${underscore1}` : `${underscore2}${text2}`).replace(/_/g, "\\_")); ++ // escape all `_` except concating with non-punctuation, e.g. `1_2_3` is not considered emphasis ++ ++ case "whitespace": ++ { ++ const parentNode = path.getParentNode(); ++ const index = parentNode.children.indexOf(node); ++ const nextNode = parentNode.children[index + 1]; ++ const proseWrap = // leading char that may cause different syntax ++ nextNode && /^>|^([-+*]|#{1,6}|[0-9]+[.)])$/.test(nextNode.value) ? "never" : options.proseWrap; ++ return printLine(path, node.value, { ++ proseWrap ++ }); ++ } ++ ++ case "emphasis": ++ { ++ const parentNode = path.getParentNode(); ++ const index = parentNode.children.indexOf(node); ++ const prevNode = parentNode.children[index - 1]; ++ const nextNode = parentNode.children[index + 1]; ++ const hasPrevOrNextWord = // `1*2*3` is considered emphasis but `1_2_3` is not ++ prevNode && prevNode.type === "sentence" && prevNode.children.length > 0 && util$1.getLast(prevNode.children).type === "word" && !util$1.getLast(prevNode.children).hasTrailingPunctuation || nextNode && nextNode.type === "sentence" && nextNode.children.length > 0 && nextNode.children[0].type === "word" && !nextNode.children[0].hasLeadingPunctuation; ++ const style = hasPrevOrNextWord || getAncestorNode$2(path, "emphasis") ? "*" : "_"; ++ return concat$d([style, printChildren$1(path, options, print), style]); ++ } ++ ++ case "strong": ++ return concat$d(["**", printChildren$1(path, options, print), "**"]); ++ ++ case "delete": ++ return concat$d(["~~", printChildren$1(path, options, print), "~~"]); ++ ++ case "inlineCode": ++ { ++ const backtickCount = util$1.getMinNotPresentContinuousCount(node.value, "`"); ++ const style = "`".repeat(backtickCount || 1); ++ const gap = backtickCount ? " " : ""; ++ return concat$d([style, gap, node.value, gap, style]); ++ } ++ ++ case "link": ++ switch (options.originalText[node.position.start.offset]) { ++ case "<": ++ { ++ const mailto = "mailto:"; ++ const url = // is parsed as { url: "mailto:hello@example.com" } ++ node.url.startsWith(mailto) && options.originalText.slice(node.position.start.offset + 1, node.position.start.offset + 1 + mailto.length) !== mailto ? node.url.slice(mailto.length) : node.url; ++ return concat$d(["<", url, ">"]); ++ } ++ ++ case "[": ++ return concat$d(["[", printChildren$1(path, options, print), "](", printUrl(node.url, ")"), printTitle(node.title, options), ")"]); ++ ++ default: ++ return options.originalText.slice(node.position.start.offset, node.position.end.offset); ++ } ++ ++ case "image": ++ return concat$d(["![", node.alt || "", "](", printUrl(node.url, ")"), printTitle(node.title, options), ")"]); ++ ++ case "blockquote": ++ return concat$d(["> ", align$2("> ", printChildren$1(path, options, print))]); ++ ++ case "heading": ++ return concat$d(["#".repeat(node.depth) + " ", printChildren$1(path, options, print)]); ++ ++ case "code": ++ { ++ if (node.isIndented) { ++ // indented code block ++ const alignment = " ".repeat(4); ++ return align$2(alignment, concat$d([alignment, concat$d(replaceEndOfLineWith$1(node.value, hardline$b))])); ++ } // fenced code block ++ ++ ++ const styleUnit = options.__inJsTemplate ? "~" : "`"; ++ const style = styleUnit.repeat(Math.max(3, util$1.getMaxContinuousCount(node.value, styleUnit) + 1)); ++ return concat$d([style, node.lang || "", hardline$b, concat$d(replaceEndOfLineWith$1(getFencedCodeBlockValue$2(node, options.originalText), hardline$b)), hardline$b, style]); ++ } ++ ++ case "yaml": ++ case "toml": ++ return options.originalText.slice(node.position.start.offset, node.position.end.offset); ++ ++ case "html": ++ { ++ const parentNode = path.getParentNode(); ++ const value = parentNode.type === "root" && util$1.getLast(parentNode.children) === node ? node.value.trimEnd() : node.value; ++ const isHtmlComment = /^$/.test(value); ++ return concat$d(replaceEndOfLineWith$1(value, isHtmlComment ? hardline$b : markAsRoot$3(literalline$5))); ++ } ++ ++ case "list": ++ { ++ const nthSiblingIndex = getNthListSiblingIndex(node, path.getParentNode()); ++ const isGitDiffFriendlyOrderedList = hasGitDiffFriendlyOrderedList$1(node, options); ++ return printChildren$1(path, options, print, { ++ processor: (childPath, index) => { ++ const prefix = getPrefix(); ++ const childNode = childPath.getValue(); ++ ++ if (childNode.children.length === 2 && childNode.children[1].type === "html" && childNode.children[0].position.start.column !== childNode.children[1].position.start.column) { ++ return concat$d([prefix, printListItem(childPath, options, print, prefix)]); ++ } ++ ++ return concat$d([prefix, align$2(" ".repeat(prefix.length), printListItem(childPath, options, print, prefix))]); ++ ++ function getPrefix() { ++ const rawPrefix = node.ordered ? (index === 0 ? node.start : isGitDiffFriendlyOrderedList ? 1 : node.start + index) + (nthSiblingIndex % 2 === 0 ? ". " : ") ") : nthSiblingIndex % 2 === 0 ? "- " : "* "; ++ return node.isAligned || ++ /* workaround for https://github.com/remarkjs/remark/issues/315 */ ++ node.hasIndentedCodeblock ? alignListPrefix(rawPrefix, options) : rawPrefix; ++ } ++ } ++ }); ++ } ++ ++ case "thematicBreak": ++ { ++ const counter = getAncestorCounter$1(path, "list"); ++ ++ if (counter === -1) { ++ return "---"; ++ } ++ ++ const nthSiblingIndex = getNthListSiblingIndex(path.getParentNode(counter), path.getParentNode(counter + 1)); ++ return nthSiblingIndex % 2 === 0 ? "***" : "---"; ++ } ++ ++ case "linkReference": ++ return concat$d(["[", printChildren$1(path, options, print), "]", node.referenceType === "full" ? concat$d(["[", node.identifier, "]"]) : node.referenceType === "collapsed" ? "[]" : ""]); ++ ++ case "imageReference": ++ switch (node.referenceType) { ++ case "full": ++ return concat$d(["![", node.alt || "", "][", node.identifier, "]"]); ++ ++ default: ++ return concat$d(["![", node.alt, "]", node.referenceType === "collapsed" ? "[]" : ""]); ++ } ++ ++ case "definition": ++ { ++ const lineOrSpace = options.proseWrap === "always" ? line$8 : " "; ++ return group$d(concat$d([concat$d(["[", node.identifier, "]:"]), indent$8(concat$d([lineOrSpace, printUrl(node.url), node.title === null ? "" : concat$d([lineOrSpace, printTitle(node.title, options, false)])]))])); ++ } ++ ++ case "footnote": ++ return concat$d(["[^", printChildren$1(path, options, print), "]"]); ++ ++ case "footnoteReference": ++ return concat$d(["[^", node.identifier, "]"]); ++ ++ case "footnoteDefinition": ++ { ++ const nextNode = path.getParentNode().children[path.getName() + 1]; ++ const shouldInlineFootnote = node.children.length === 1 && node.children[0].type === "paragraph" && (options.proseWrap === "never" || options.proseWrap === "preserve" && node.children[0].position.start.line === node.children[0].position.end.line); ++ return concat$d(["[^", node.identifier, "]: ", shouldInlineFootnote ? printChildren$1(path, options, print) : group$d(concat$d([align$2(" ".repeat(options.tabWidth), printChildren$1(path, options, print, { ++ processor: (childPath, index) => { ++ return index === 0 ? group$d(concat$d([softline$6, childPath.call(print)])) : childPath.call(print); ++ } ++ })), nextNode && nextNode.type === "footnoteDefinition" ? softline$6 : ""]))]); ++ } ++ ++ case "table": ++ return printTable(path, options, print); ++ ++ case "tableCell": ++ return printChildren$1(path, options, print); ++ ++ case "break": ++ return /\s/.test(options.originalText[node.position.start.offset]) ? concat$d([" ", markAsRoot$3(literalline$5)]) : concat$d(["\\", hardline$b]); ++ ++ case "liquidNode": ++ return concat$d(replaceEndOfLineWith$1(node.value, hardline$b)); ++ // MDX ++ ++ case "importExport": ++ case "jsx": ++ return node.value; ++ // fallback to the original text if multiparser failed ++ ++ case "math": ++ return concat$d(["$$", hardline$b, node.value ? concat$d([concat$d(replaceEndOfLineWith$1(node.value, hardline$b)), hardline$b]) : "", "$$"]); ++ ++ case "inlineMath": ++ { ++ // remark-math trims content but we don't want to remove whitespaces ++ // since it's very possible that it's recognized as math accidentally ++ return options.originalText.slice(options.locStart(node), options.locEnd(node)); ++ } ++ ++ case "tableRow": // handled in "table" ++ ++ case "listItem": // handled in "list" ++ ++ default: ++ throw new Error(`Unknown markdown type ${JSON.stringify(node.type)}`); ++ } ++} ++ ++function printListItem(path, options, print, listPrefix) { ++ const node = path.getValue(); ++ const prefix = node.checked === null ? "" : node.checked ? "[x] " : "[ ] "; ++ return concat$d([prefix, printChildren$1(path, options, print, { ++ processor: (childPath, index) => { ++ if (index === 0 && childPath.getValue().type !== "list") { ++ return align$2(" ".repeat(prefix.length), childPath.call(print)); ++ } ++ ++ const alignment = " ".repeat(clamp(options.tabWidth - listPrefix.length, 0, 3) // 4+ will cause indented code block ++ ); ++ return concat$d([alignment, align$2(alignment, childPath.call(print))]); ++ } ++ })]); ++} ++ ++function alignListPrefix(prefix, options) { ++ const additionalSpaces = getAdditionalSpaces(); ++ return prefix + " ".repeat(additionalSpaces >= 4 ? 0 : additionalSpaces // 4+ will cause indented code block ++ ); ++ ++ function getAdditionalSpaces() { ++ const restSpaces = prefix.length % options.tabWidth; ++ return restSpaces === 0 ? 0 : options.tabWidth - restSpaces; ++ } ++} ++ ++function getNthListSiblingIndex(node, parentNode) { ++ return getNthSiblingIndex(node, parentNode, siblingNode => siblingNode.ordered === node.ordered); ++} ++ ++function getNthSiblingIndex(node, parentNode, condition) { ++ condition = condition || (() => true); ++ ++ let index = -1; ++ ++ for (const childNode of parentNode.children) { ++ if (childNode.type === node.type && condition(childNode)) { ++ index++; ++ } else { ++ index = -1; ++ } ++ ++ if (childNode === node) { ++ return index; ++ } ++ } ++} ++ ++function getAncestorCounter$1(path, typeOrTypes) { ++ const types = [].concat(typeOrTypes); ++ let counter = -1; ++ let ancestorNode; ++ ++ while (ancestorNode = path.getParentNode(++counter)) { ++ if (types.includes(ancestorNode.type)) { ++ return counter; ++ } ++ } ++ ++ return -1; ++} ++ ++function getAncestorNode$2(path, typeOrTypes) { ++ const counter = getAncestorCounter$1(path, typeOrTypes); ++ return counter === -1 ? null : path.getParentNode(counter); ++} ++ ++function printLine(path, value, options) { ++ if (options.proseWrap === "preserve" && value === "\n") { ++ return hardline$b; ++ } ++ ++ const isBreakable = options.proseWrap === "always" && !getAncestorNode$2(path, SINGLE_LINE_NODE_TYPES); ++ return value !== "" ? isBreakable ? line$8 : " " : isBreakable ? softline$6 : ""; ++} ++ ++function printTable(path, options, print) { ++ const hardlineWithoutBreakParent = hardline$b.parts[0]; ++ const node = path.getValue(); ++ const contents = []; // { [rowIndex: number]: { [columnIndex: number]: string } } ++ ++ path.map(rowPath => { ++ const rowContents = []; ++ rowPath.map(cellPath => { ++ rowContents.push(printDocToString$3(cellPath.call(print), options).formatted); ++ }, "children"); ++ contents.push(rowContents); ++ }, "children"); // Get the width of each column ++ ++ const columnMaxWidths = contents.reduce((currentWidths, rowContents) => currentWidths.map((width, columnIndex) => Math.max(width, util$1.getStringWidth(rowContents[columnIndex]))), contents[0].map(() => 3) // minimum width = 3 (---, :--, :-:, --:) ++ ); ++ const alignedTable = join$9(hardlineWithoutBreakParent, [printRow(contents[0]), printSeparator(), join$9(hardlineWithoutBreakParent, contents.slice(1).map(rowContents => printRow(rowContents)))]); ++ ++ if (options.proseWrap !== "never") { ++ return concat$d([breakParent$3, alignedTable]); ++ } // Only if the --prose-wrap never is set and it exceeds the print width. ++ ++ ++ const compactTable = join$9(hardlineWithoutBreakParent, [printRow(contents[0], ++ /* isCompact */ ++ true), printSeparator( ++ /* isCompact */ ++ true), join$9(hardlineWithoutBreakParent, contents.slice(1).map(rowContents => printRow(rowContents, ++ /* isCompact */ ++ true)))]); ++ return concat$d([breakParent$3, group$d(ifBreak$5(compactTable, alignedTable))]); ++ ++ function printSeparator(isCompact) { ++ return concat$d(["| ", join$9(" | ", columnMaxWidths.map((width, index) => { ++ const spaces = isCompact ? 3 : width; ++ ++ switch (node.align[index]) { ++ case "left": ++ return ":" + "-".repeat(spaces - 1); ++ ++ case "right": ++ return "-".repeat(spaces - 1) + ":"; ++ ++ case "center": ++ return ":" + "-".repeat(spaces - 2) + ":"; ++ ++ default: ++ return "-".repeat(spaces); ++ } ++ })), " |"]); ++ } ++ ++ function printRow(rowContents, isCompact) { ++ return concat$d(["| ", join$9(" | ", isCompact ? rowContents : rowContents.map((rowContent, columnIndex) => { ++ switch (node.align[columnIndex]) { ++ case "right": ++ return alignRight(rowContent, columnMaxWidths[columnIndex]); ++ ++ case "center": ++ return alignCenter(rowContent, columnMaxWidths[columnIndex]); ++ ++ default: ++ return alignLeft(rowContent, columnMaxWidths[columnIndex]); ++ } ++ })), " |"]); ++ } ++ ++ function alignLeft(text, width) { ++ const spaces = width - util$1.getStringWidth(text); ++ return concat$d([text, " ".repeat(spaces)]); ++ } ++ ++ function alignRight(text, width) { ++ const spaces = width - util$1.getStringWidth(text); ++ return concat$d([" ".repeat(spaces), text]); ++ } ++ ++ function alignCenter(text, width) { ++ const spaces = width - util$1.getStringWidth(text); ++ const left = Math.floor(spaces / 2); ++ const right = spaces - left; ++ return concat$d([" ".repeat(left), text, " ".repeat(right)]); ++ } ++} ++ ++function printRoot(path, options, print) { ++ /** @typedef {{ index: number, offset: number }} IgnorePosition */ ++ ++ /** @type {Array<{start: IgnorePosition, end: IgnorePosition}>} */ ++ const ignoreRanges = []; ++ /** @type {IgnorePosition | null} */ ++ ++ let ignoreStart = null; ++ const { ++ children ++ } = path.getValue(); ++ children.forEach((childNode, index) => { ++ switch (isPrettierIgnore(childNode)) { ++ case "start": ++ if (ignoreStart === null) { ++ ignoreStart = { ++ index, ++ offset: childNode.position.end.offset ++ }; ++ } ++ ++ break; ++ ++ case "end": ++ if (ignoreStart !== null) { ++ ignoreRanges.push({ ++ start: ignoreStart, ++ end: { ++ index, ++ offset: childNode.position.start.offset ++ } ++ }); ++ ignoreStart = null; ++ } ++ ++ break; ++ } ++ }); ++ return printChildren$1(path, options, print, { ++ processor: (childPath, index) => { ++ if (ignoreRanges.length !== 0) { ++ const ignoreRange = ignoreRanges[0]; ++ ++ if (index === ignoreRange.start.index) { ++ return concat$d([children[ignoreRange.start.index].value, options.originalText.slice(ignoreRange.start.offset, ignoreRange.end.offset), children[ignoreRange.end.index].value]); ++ } ++ ++ if (ignoreRange.start.index < index && index < ignoreRange.end.index) { ++ return false; ++ } ++ ++ if (index === ignoreRange.end.index) { ++ ignoreRanges.shift(); ++ return false; ++ } ++ } ++ ++ return childPath.call(print); ++ } ++ }); ++} ++ ++function printChildren$1(path, options, print, events) { ++ events = events || {}; ++ const postprocessor = events.postprocessor || concat$d; ++ ++ const processor = events.processor || (childPath => childPath.call(print)); ++ ++ const node = path.getValue(); ++ const parts = []; ++ let lastChildNode; ++ path.map((childPath, index) => { ++ const childNode = childPath.getValue(); ++ const result = processor(childPath, index); ++ ++ if (result !== false) { ++ const data = { ++ parts, ++ prevNode: lastChildNode, ++ parentNode: node, ++ options ++ }; ++ ++ if (!shouldNotPrePrintHardline(childNode, data)) { ++ parts.push(hardline$b); ++ ++ if (lastChildNode && TRAILING_HARDLINE_NODES.includes(lastChildNode.type)) { ++ if (shouldPrePrintTripleHardline(childNode, data)) { ++ parts.push(hardline$b); ++ } ++ } else { ++ if (shouldPrePrintDoubleHardline(childNode, data) || shouldPrePrintTripleHardline(childNode, data)) { ++ parts.push(hardline$b); ++ } ++ ++ if (shouldPrePrintTripleHardline(childNode, data)) { ++ parts.push(hardline$b); ++ } ++ } ++ } ++ ++ parts.push(result); ++ lastChildNode = childNode; ++ } ++ }, "children"); ++ return postprocessor(parts); ++} ++ ++function getLastDescendantNode(node) { ++ let current = node; ++ ++ while (current.children && current.children.length !== 0) { ++ current = current.children[current.children.length - 1]; ++ } ++ ++ return current; ++} ++/** @return {false | 'next' | 'start' | 'end'} */ ++ ++ ++function isPrettierIgnore(node) { ++ if (node.type !== "html") { ++ return false; ++ } ++ ++ const match = node.value.match(/^$/); ++ return match === null ? false : match[1] ? match[1] : "next"; ++} ++ ++function shouldNotPrePrintHardline(node, data) { ++ const isFirstNode = data.parts.length === 0; ++ const isInlineNode = INLINE_NODE_TYPES$1.includes(node.type); ++ const isInlineHTML = node.type === "html" && INLINE_NODE_WRAPPER_TYPES$1.includes(data.parentNode.type); ++ return isFirstNode || isInlineNode || isInlineHTML; ++} ++ ++function shouldPrePrintDoubleHardline(node, data) { ++ const isSequence = (data.prevNode && data.prevNode.type) === node.type; ++ const isSiblingNode = isSequence && SIBLING_NODE_TYPES.includes(node.type); ++ const isInTightListItem = data.parentNode.type === "listItem" && !data.parentNode.loose; ++ const isPrevNodeLooseListItem = data.prevNode && data.prevNode.type === "listItem" && data.prevNode.loose; ++ const isPrevNodePrettierIgnore = isPrettierIgnore(data.prevNode) === "next"; ++ const isBlockHtmlWithoutBlankLineBetweenPrevHtml = node.type === "html" && data.prevNode && data.prevNode.type === "html" && data.prevNode.position.end.line + 1 === node.position.start.line; ++ const isHtmlDirectAfterListItem = node.type === "html" && data.parentNode.type === "listItem" && data.prevNode && data.prevNode.type === "paragraph" && data.prevNode.position.end.line + 1 === node.position.start.line; ++ return isPrevNodeLooseListItem || !(isSiblingNode || isInTightListItem || isPrevNodePrettierIgnore || isBlockHtmlWithoutBlankLineBetweenPrevHtml || isHtmlDirectAfterListItem); ++} ++ ++function shouldPrePrintTripleHardline(node, data) { ++ const isPrevNodeList = data.prevNode && data.prevNode.type === "list"; ++ const isIndentedCode = node.type === "code" && node.isIndented; ++ return isPrevNodeList && isIndentedCode; ++} ++ ++function shouldRemainTheSameContent(path) { ++ const ancestorNode = getAncestorNode$2(path, ["linkReference", "imageReference"]); ++ return ancestorNode && (ancestorNode.type !== "linkReference" || ancestorNode.referenceType !== "full"); ++} ++ ++function normalizeDoc(doc) { ++ return mapDoc$5(doc, currentDoc => { ++ if (!currentDoc.parts) { ++ return currentDoc; ++ } ++ ++ if (currentDoc.type === "concat" && currentDoc.parts.length === 1) { ++ return currentDoc.parts[0]; ++ } ++ ++ const parts = currentDoc.parts.reduce((parts, part) => { ++ if (part.type === "concat") { ++ parts.push(...part.parts); ++ } else if (part !== "") { ++ parts.push(part); ++ } ++ ++ return parts; ++ }, []); ++ return Object.assign({}, currentDoc, { ++ parts: normalizeParts(parts) ++ }); ++ }); ++} ++ ++function printUrl(url, dangerousCharOrChars) { ++ const dangerousChars = [" "].concat(dangerousCharOrChars || []); ++ return new RegExp(dangerousChars.map(x => `\\${x}`).join("|")).test(url) ? `<${url}>` : url; ++} ++ ++function printTitle(title, options, printSpace) { ++ if (printSpace == null) { ++ printSpace = true; ++ } ++ ++ if (!title) { ++ return ""; ++ } ++ ++ if (printSpace) { ++ return " " + printTitle(title, options, false); ++ } ++ ++ if (title.includes('"') && title.includes("'") && !title.includes(")")) { ++ return `(${title})`; // avoid escaped quotes ++ } // faster than using RegExps: https://jsperf.com/performance-of-match-vs-split ++ ++ ++ const singleCount = title.split("'").length - 1; ++ const doubleCount = title.split('"').length - 1; ++ const quote = singleCount > doubleCount ? '"' : doubleCount > singleCount ? "'" : options.singleQuote ? "'" : '"'; ++ title = title.replace(new RegExp(`(${quote})`, "g"), "\\$1"); ++ return `${quote}${title}${quote}`; ++} ++ ++function normalizeParts(parts) { ++ return parts.reduce((current, part) => { ++ const lastPart = util$1.getLast(current); ++ ++ if (typeof lastPart === "string" && typeof part === "string") { ++ current.splice(-1, 1, lastPart + part); ++ } else { ++ current.push(part); ++ } ++ ++ return current; ++ }, []); ++} ++ ++function clamp(value, min, max) { ++ return value < min ? min : value > max ? max : value; ++} ++ ++function clean$5(ast, newObj, parent) { ++ delete newObj.position; ++ delete newObj.raw; // front-matter ++ // for codeblock ++ ++ if (ast.type === "code" || ast.type === "yaml" || ast.type === "import" || ast.type === "export" || ast.type === "jsx") { ++ delete newObj.value; ++ } ++ ++ if (ast.type === "list") { ++ delete newObj.isAligned; ++ } // texts can be splitted or merged ++ ++ ++ if (ast.type === "text") { ++ return null; ++ } ++ ++ if (ast.type === "inlineCode") { ++ newObj.value = ast.value.replace(/[ \t\n]+/g, " "); ++ } // for insert pragma ++ ++ ++ if (parent && parent.type === "root" && parent.children.length > 0 && (parent.children[0] === ast || (parent.children[0].type === "yaml" || parent.children[0].type === "toml") && parent.children[1] === ast) && ast.type === "html" && pragma$3.startWithPragma(ast.value)) { ++ return null; ++ } ++} ++ ++function hasPrettierIgnore$4(path) { ++ const index = +path.getName(); ++ ++ if (index === 0) { ++ return false; ++ } ++ ++ const prevNode = path.getParentNode().children[index - 1]; ++ return isPrettierIgnore(prevNode) === "next"; ++} ++ ++var printerMarkdown = { ++ preprocess: preprocess_1$1, ++ print: genericPrint$4, ++ embed: embed_1$2, ++ massageAstNode: clean$5, ++ hasPrettierIgnore: hasPrettierIgnore$4, ++ insertPragma: pragma$3.insertPragma ++}; ++ ++var options$5 = { ++ proseWrap: commonOptions.proseWrap, ++ singleQuote: commonOptions.singleQuote ++}; ++ ++var name$f = "Markdown"; ++var type$d = "prose"; ++var aliases$4 = [ ++ "pandoc" ++]; ++var aceMode$d = "markdown"; ++var codemirrorMode$a = "gfm"; ++var codemirrorMimeType$a = "text/x-gfm"; ++var wrap = true; ++var extensions$d = [ ++ ".md", ++ ".markdown", ++ ".mdown", ++ ".mdwn", ++ ".mdx", ++ ".mkd", ++ ".mkdn", ++ ".mkdown", ++ ".ronn", ++ ".workbook" ++]; ++var filenames$3 = [ ++ "contents.lr" ++]; ++var tmScope$d = "source.gfm"; ++var languageId$d = 222; ++var Markdown = { ++ name: name$f, ++ type: type$d, ++ aliases: aliases$4, ++ aceMode: aceMode$d, ++ codemirrorMode: codemirrorMode$a, ++ codemirrorMimeType: codemirrorMimeType$a, ++ wrap: wrap, ++ extensions: extensions$d, ++ filenames: filenames$3, ++ tmScope: tmScope$d, ++ languageId: languageId$d ++}; ++ ++var Markdown$1 = /*#__PURE__*/Object.freeze({ ++ __proto__: null, ++ name: name$f, ++ type: type$d, ++ aliases: aliases$4, ++ aceMode: aceMode$d, ++ codemirrorMode: codemirrorMode$a, ++ codemirrorMimeType: codemirrorMimeType$a, ++ wrap: wrap, ++ extensions: extensions$d, ++ filenames: filenames$3, ++ tmScope: tmScope$d, ++ languageId: languageId$d, ++ 'default': Markdown ++}); ++ ++var require$$0$5 = getCjsExportFromNamespace(Markdown$1); ++ ++const languages$4 = [createLanguage(require$$0$5, data => ({ ++ since: "1.8.0", ++ parsers: ["markdown"], ++ vscodeLanguageIds: ["markdown"], ++ filenames: data.filenames.concat(["README"]), ++ extensions: data.extensions.filter(extension => extension !== ".mdx") ++})), createLanguage(require$$0$5, () => ({ ++ name: "MDX", ++ since: "1.15.0", ++ parsers: ["mdx"], ++ vscodeLanguageIds: ["mdx"], ++ filenames: [], ++ extensions: [".mdx"] ++}))]; ++const printers$4 = { ++ mdast: printerMarkdown ++}; ++var languageMarkdown = { ++ languages: languages$4, ++ options: options$5, ++ printers: printers$4 ++}; ++ ++var clean$6 = function (ast, newNode) { ++ delete newNode.sourceSpan; ++ delete newNode.startSourceSpan; ++ delete newNode.endSourceSpan; ++ delete newNode.nameSpan; ++ delete newNode.valueSpan; ++ ++ if (ast.type === "text" || ast.type === "comment") { ++ return null; ++ } // may be formatted by multiparser ++ ++ ++ if (ast.type === "yaml" || ast.type === "toml") { ++ return null; ++ } ++ ++ if (ast.type === "attribute") { ++ delete newNode.value; ++ } ++ ++ if (ast.type === "docType") { ++ delete newNode.value; ++ } ++}; ++ ++var json$1 = { ++ "CSS_DISPLAY_TAGS": { ++ "area": "none", ++ "base": "none", ++ "basefont": "none", ++ "datalist": "none", ++ "head": "none", ++ "link": "none", ++ "meta": "none", ++ "noembed": "none", ++ "noframes": "none", ++ "param": "none", ++ "rp": "none", ++ "script": "block", ++ "source": "block", ++ "style": "none", ++ "template": "inline", ++ "track": "block", ++ "title": "none", ++ "html": "block", ++ "body": "block", ++ "address": "block", ++ "blockquote": "block", ++ "center": "block", ++ "div": "block", ++ "figure": "block", ++ "figcaption": "block", ++ "footer": "block", ++ "form": "block", ++ "header": "block", ++ "hr": "block", ++ "legend": "block", ++ "listing": "block", ++ "main": "block", ++ "p": "block", ++ "plaintext": "block", ++ "pre": "block", ++ "xmp": "block", ++ "slot": "contents", ++ "ruby": "ruby", ++ "rt": "ruby-text", ++ "article": "block", ++ "aside": "block", ++ "h1": "block", ++ "h2": "block", ++ "h3": "block", ++ "h4": "block", ++ "h5": "block", ++ "h6": "block", ++ "hgroup": "block", ++ "nav": "block", ++ "section": "block", ++ "dir": "block", ++ "dd": "block", ++ "dl": "block", ++ "dt": "block", ++ "ol": "block", ++ "ul": "block", ++ "li": "list-item", ++ "table": "table", ++ "caption": "table-caption", ++ "colgroup": "table-column-group", ++ "col": "table-column", ++ "thead": "table-header-group", ++ "tbody": "table-row-group", ++ "tfoot": "table-footer-group", ++ "tr": "table-row", ++ "td": "table-cell", ++ "th": "table-cell", ++ "fieldset": "block", ++ "button": "inline-block", ++ "video": "inline-block", ++ "audio": "inline-block" ++ }, ++ "CSS_DISPLAY_DEFAULT": "inline", ++ "CSS_WHITE_SPACE_TAGS": { ++ "listing": "pre", ++ "plaintext": "pre", ++ "pre": "pre", ++ "xmp": "pre", ++ "nobr": "nowrap", ++ "table": "initial", ++ "textarea": "pre-wrap" ++ }, ++ "CSS_WHITE_SPACE_DEFAULT": "normal" ++}; ++ ++var index = [ ++ "a", ++ "abbr", ++ "acronym", ++ "address", ++ "applet", ++ "area", ++ "article", ++ "aside", ++ "audio", ++ "b", ++ "base", ++ "basefont", ++ "bdi", ++ "bdo", ++ "bgsound", ++ "big", ++ "blink", ++ "blockquote", ++ "body", ++ "br", ++ "button", ++ "canvas", ++ "caption", ++ "center", ++ "cite", ++ "code", ++ "col", ++ "colgroup", ++ "command", ++ "content", ++ "data", ++ "datalist", ++ "dd", ++ "del", ++ "details", ++ "dfn", ++ "dialog", ++ "dir", ++ "div", ++ "dl", ++ "dt", ++ "element", ++ "em", ++ "embed", ++ "fieldset", ++ "figcaption", ++ "figure", ++ "font", ++ "footer", ++ "form", ++ "frame", ++ "frameset", ++ "h1", ++ "h2", ++ "h3", ++ "h4", ++ "h5", ++ "h6", ++ "head", ++ "header", ++ "hgroup", ++ "hr", ++ "html", ++ "i", ++ "iframe", ++ "image", ++ "img", ++ "input", ++ "ins", ++ "isindex", ++ "kbd", ++ "keygen", ++ "label", ++ "legend", ++ "li", ++ "link", ++ "listing", ++ "main", ++ "map", ++ "mark", ++ "marquee", ++ "math", ++ "menu", ++ "menuitem", ++ "meta", ++ "meter", ++ "multicol", ++ "nav", ++ "nextid", ++ "nobr", ++ "noembed", ++ "noframes", ++ "noscript", ++ "object", ++ "ol", ++ "optgroup", ++ "option", ++ "output", ++ "p", ++ "param", ++ "picture", ++ "plaintext", ++ "pre", ++ "progress", ++ "q", ++ "rb", ++ "rbc", ++ "rp", ++ "rt", ++ "rtc", ++ "ruby", ++ "s", ++ "samp", ++ "script", ++ "section", ++ "select", ++ "shadow", ++ "slot", ++ "small", ++ "source", ++ "spacer", ++ "span", ++ "strike", ++ "strong", ++ "style", ++ "sub", ++ "summary", ++ "sup", ++ "svg", ++ "table", ++ "tbody", ++ "td", ++ "template", ++ "textarea", ++ "tfoot", ++ "th", ++ "thead", ++ "time", ++ "title", ++ "tr", ++ "track", ++ "tt", ++ "u", ++ "ul", ++ "var", ++ "video", ++ "wbr", ++ "xmp" ++]; ++ ++var htmlTagNames = /*#__PURE__*/Object.freeze({ ++ __proto__: null, ++ 'default': index ++}); ++ ++var a = [ ++ "accesskey", ++ "charset", ++ "coords", ++ "download", ++ "href", ++ "hreflang", ++ "name", ++ "ping", ++ "referrerpolicy", ++ "rel", ++ "rev", ++ "shape", ++ "tabindex", ++ "target", ++ "type" ++]; ++var abbr = [ ++ "title" ++]; ++var applet = [ ++ "align", ++ "alt", ++ "archive", ++ "code", ++ "codebase", ++ "height", ++ "hspace", ++ "name", ++ "object", ++ "vspace", ++ "width" ++]; ++var area = [ ++ "accesskey", ++ "alt", ++ "coords", ++ "download", ++ "href", ++ "hreflang", ++ "nohref", ++ "ping", ++ "referrerpolicy", ++ "rel", ++ "shape", ++ "tabindex", ++ "target", ++ "type" ++]; ++var audio = [ ++ "autoplay", ++ "controls", ++ "crossorigin", ++ "loop", ++ "muted", ++ "preload", ++ "src" ++]; ++var base = [ ++ "href", ++ "target" ++]; ++var basefont = [ ++ "color", ++ "face", ++ "size" ++]; ++var bdo = [ ++ "dir" ++]; ++var blockquote = [ ++ "cite" ++]; ++var body = [ ++ "alink", ++ "background", ++ "bgcolor", ++ "link", ++ "text", ++ "vlink" ++]; ++var br = [ ++ "clear" ++]; ++var button = [ ++ "accesskey", ++ "autofocus", ++ "disabled", ++ "form", ++ "formaction", ++ "formenctype", ++ "formmethod", ++ "formnovalidate", ++ "formtarget", ++ "name", ++ "tabindex", ++ "type", ++ "value" ++]; ++var canvas = [ ++ "height", ++ "width" ++]; ++var caption = [ ++ "align" ++]; ++var col = [ ++ "align", ++ "char", ++ "charoff", ++ "span", ++ "valign", ++ "width" ++]; ++var colgroup = [ ++ "align", ++ "char", ++ "charoff", ++ "span", ++ "valign", ++ "width" ++]; ++var data = [ ++ "value" ++]; ++var del$1 = [ ++ "cite", ++ "datetime" ++]; ++var details = [ ++ "open" ++]; ++var dfn = [ ++ "title" ++]; ++var dialog = [ ++ "open" ++]; ++var dir = [ ++ "compact" ++]; ++var div = [ ++ "align" ++]; ++var dl = [ ++ "compact" ++]; ++var embed$3 = [ ++ "height", ++ "src", ++ "type", ++ "width" ++]; ++var fieldset = [ ++ "disabled", ++ "form", ++ "name" ++]; ++var font = [ ++ "color", ++ "face", ++ "size" ++]; ++var form = [ ++ "accept", ++ "accept-charset", ++ "action", ++ "autocomplete", ++ "enctype", ++ "method", ++ "name", ++ "novalidate", ++ "target" ++]; ++var frame = [ ++ "frameborder", ++ "longdesc", ++ "marginheight", ++ "marginwidth", ++ "name", ++ "noresize", ++ "scrolling", ++ "src" ++]; ++var frameset = [ ++ "cols", ++ "rows" ++]; ++var h1 = [ ++ "align" ++]; ++var h2 = [ ++ "align" ++]; ++var h3 = [ ++ "align" ++]; ++var h4 = [ ++ "align" ++]; ++var h5 = [ ++ "align" ++]; ++var h6 = [ ++ "align" ++]; ++var head = [ ++ "profile" ++]; ++var hr = [ ++ "align", ++ "noshade", ++ "size", ++ "width" ++]; ++var html = [ ++ "manifest", ++ "version" ++]; ++var iframe = [ ++ "align", ++ "allow", ++ "allowfullscreen", ++ "allowpaymentrequest", ++ "allowusermedia", ++ "frameborder", ++ "height", ++ "longdesc", ++ "marginheight", ++ "marginwidth", ++ "name", ++ "referrerpolicy", ++ "sandbox", ++ "scrolling", ++ "src", ++ "srcdoc", ++ "width" ++]; ++var img = [ ++ "align", ++ "alt", ++ "border", ++ "crossorigin", ++ "decoding", ++ "height", ++ "hspace", ++ "ismap", ++ "longdesc", ++ "name", ++ "referrerpolicy", ++ "sizes", ++ "src", ++ "srcset", ++ "usemap", ++ "vspace", ++ "width" ++]; ++var input = [ ++ "accept", ++ "accesskey", ++ "align", ++ "alt", ++ "autocomplete", ++ "autofocus", ++ "checked", ++ "dirname", ++ "disabled", ++ "form", ++ "formaction", ++ "formenctype", ++ "formmethod", ++ "formnovalidate", ++ "formtarget", ++ "height", ++ "ismap", ++ "list", ++ "max", ++ "maxlength", ++ "min", ++ "minlength", ++ "multiple", ++ "name", ++ "pattern", ++ "placeholder", ++ "readonly", ++ "required", ++ "size", ++ "src", ++ "step", ++ "tabindex", ++ "title", ++ "type", ++ "usemap", ++ "value", ++ "width" ++]; ++var ins = [ ++ "cite", ++ "datetime" ++]; ++var isindex = [ ++ "prompt" ++]; ++var label = [ ++ "accesskey", ++ "for", ++ "form" ++]; ++var legend = [ ++ "accesskey", ++ "align" ++]; ++var li = [ ++ "type", ++ "value" ++]; ++var link$3 = [ ++ "as", ++ "charset", ++ "color", ++ "crossorigin", ++ "href", ++ "hreflang", ++ "imagesizes", ++ "imagesrcset", ++ "integrity", ++ "media", ++ "nonce", ++ "referrerpolicy", ++ "rel", ++ "rev", ++ "sizes", ++ "target", ++ "title", ++ "type" ++]; ++var map$1 = [ ++ "name" ++]; ++var menu = [ ++ "compact" ++]; ++var meta = [ ++ "charset", ++ "content", ++ "http-equiv", ++ "name", ++ "scheme" ++]; ++var meter = [ ++ "high", ++ "low", ++ "max", ++ "min", ++ "optimum", ++ "value" ++]; ++var object = [ ++ "align", ++ "archive", ++ "border", ++ "classid", ++ "codebase", ++ "codetype", ++ "data", ++ "declare", ++ "form", ++ "height", ++ "hspace", ++ "name", ++ "standby", ++ "tabindex", ++ "type", ++ "typemustmatch", ++ "usemap", ++ "vspace", ++ "width" ++]; ++var ol = [ ++ "compact", ++ "reversed", ++ "start", ++ "type" ++]; ++var optgroup = [ ++ "disabled", ++ "label" ++]; ++var option = [ ++ "disabled", ++ "label", ++ "selected", ++ "value" ++]; ++var output = [ ++ "for", ++ "form", ++ "name" ++]; ++var p = [ ++ "align" ++]; ++var param = [ ++ "name", ++ "type", ++ "value", ++ "valuetype" ++]; ++var pre = [ ++ "width" ++]; ++var progress = [ ++ "max", ++ "value" ++]; ++var q = [ ++ "cite" ++]; ++var script = [ ++ "async", ++ "charset", ++ "crossorigin", ++ "defer", ++ "integrity", ++ "language", ++ "nomodule", ++ "nonce", ++ "referrerpolicy", ++ "src", ++ "type" ++]; ++var select = [ ++ "autocomplete", ++ "autofocus", ++ "disabled", ++ "form", ++ "multiple", ++ "name", ++ "required", ++ "size", ++ "tabindex" ++]; ++var slot = [ ++ "name" ++]; ++var source$1 = [ ++ "media", ++ "sizes", ++ "src", ++ "srcset", ++ "type" ++]; ++var style = [ ++ "media", ++ "nonce", ++ "title", ++ "type" ++]; ++var table = [ ++ "align", ++ "bgcolor", ++ "border", ++ "cellpadding", ++ "cellspacing", ++ "frame", ++ "rules", ++ "summary", ++ "width" ++]; ++var tbody = [ ++ "align", ++ "char", ++ "charoff", ++ "valign" ++]; ++var td = [ ++ "abbr", ++ "align", ++ "axis", ++ "bgcolor", ++ "char", ++ "charoff", ++ "colspan", ++ "headers", ++ "height", ++ "nowrap", ++ "rowspan", ++ "scope", ++ "valign", ++ "width" ++]; ++var textarea = [ ++ "accesskey", ++ "autocomplete", ++ "autofocus", ++ "cols", ++ "dirname", ++ "disabled", ++ "form", ++ "maxlength", ++ "minlength", ++ "name", ++ "placeholder", ++ "readonly", ++ "required", ++ "rows", ++ "tabindex", ++ "wrap" ++]; ++var tfoot = [ ++ "align", ++ "char", ++ "charoff", ++ "valign" ++]; ++var th = [ ++ "abbr", ++ "align", ++ "axis", ++ "bgcolor", ++ "char", ++ "charoff", ++ "colspan", ++ "headers", ++ "height", ++ "nowrap", ++ "rowspan", ++ "scope", ++ "valign", ++ "width" ++]; ++var thead = [ ++ "align", ++ "char", ++ "charoff", ++ "valign" ++]; ++var time = [ ++ "datetime" ++]; ++var tr = [ ++ "align", ++ "bgcolor", ++ "char", ++ "charoff", ++ "valign" ++]; ++var track = [ ++ "default", ++ "kind", ++ "label", ++ "src", ++ "srclang" ++]; ++var ul = [ ++ "compact", ++ "type" ++]; ++var video = [ ++ "autoplay", ++ "controls", ++ "crossorigin", ++ "height", ++ "loop", ++ "muted", ++ "playsinline", ++ "poster", ++ "preload", ++ "src", ++ "width" ++]; ++var index$1 = { ++ "*": [ ++ "accesskey", ++ "autocapitalize", ++ "autofocus", ++ "class", ++ "contenteditable", ++ "dir", ++ "draggable", ++ "enterkeyhint", ++ "hidden", ++ "id", ++ "inputmode", ++ "is", ++ "itemid", ++ "itemprop", ++ "itemref", ++ "itemscope", ++ "itemtype", ++ "lang", ++ "nonce", ++ "slot", ++ "spellcheck", ++ "style", ++ "tabindex", ++ "title", ++ "translate" ++], ++ a: a, ++ abbr: abbr, ++ applet: applet, ++ area: area, ++ audio: audio, ++ base: base, ++ basefont: basefont, ++ bdo: bdo, ++ blockquote: blockquote, ++ body: body, ++ br: br, ++ button: button, ++ canvas: canvas, ++ caption: caption, ++ col: col, ++ colgroup: colgroup, ++ data: data, ++ del: del$1, ++ details: details, ++ dfn: dfn, ++ dialog: dialog, ++ dir: dir, ++ div: div, ++ dl: dl, ++ embed: embed$3, ++ fieldset: fieldset, ++ font: font, ++ form: form, ++ frame: frame, ++ frameset: frameset, ++ h1: h1, ++ h2: h2, ++ h3: h3, ++ h4: h4, ++ h5: h5, ++ h6: h6, ++ head: head, ++ hr: hr, ++ html: html, ++ iframe: iframe, ++ img: img, ++ input: input, ++ ins: ins, ++ isindex: isindex, ++ label: label, ++ legend: legend, ++ li: li, ++ link: link$3, ++ map: map$1, ++ menu: menu, ++ meta: meta, ++ meter: meter, ++ object: object, ++ ol: ol, ++ optgroup: optgroup, ++ option: option, ++ output: output, ++ p: p, ++ param: param, ++ pre: pre, ++ progress: progress, ++ q: q, ++ script: script, ++ select: select, ++ slot: slot, ++ source: source$1, ++ style: style, ++ table: table, ++ tbody: tbody, ++ td: td, ++ textarea: textarea, ++ tfoot: tfoot, ++ th: th, ++ thead: thead, ++ time: time, ++ tr: tr, ++ track: track, ++ ul: ul, ++ video: video ++}; ++ ++var htmlElementAttributes = /*#__PURE__*/Object.freeze({ ++ __proto__: null, ++ a: a, ++ abbr: abbr, ++ applet: applet, ++ area: area, ++ audio: audio, ++ base: base, ++ basefont: basefont, ++ bdo: bdo, ++ blockquote: blockquote, ++ body: body, ++ br: br, ++ button: button, ++ canvas: canvas, ++ caption: caption, ++ col: col, ++ colgroup: colgroup, ++ data: data, ++ del: del$1, ++ details: details, ++ dfn: dfn, ++ dialog: dialog, ++ dir: dir, ++ div: div, ++ dl: dl, ++ embed: embed$3, ++ fieldset: fieldset, ++ font: font, ++ form: form, ++ frame: frame, ++ frameset: frameset, ++ h1: h1, ++ h2: h2, ++ h3: h3, ++ h4: h4, ++ h5: h5, ++ h6: h6, ++ head: head, ++ hr: hr, ++ html: html, ++ iframe: iframe, ++ img: img, ++ input: input, ++ ins: ins, ++ isindex: isindex, ++ label: label, ++ legend: legend, ++ li: li, ++ link: link$3, ++ map: map$1, ++ menu: menu, ++ meta: meta, ++ meter: meter, ++ object: object, ++ ol: ol, ++ optgroup: optgroup, ++ option: option, ++ output: output, ++ p: p, ++ param: param, ++ pre: pre, ++ progress: progress, ++ q: q, ++ script: script, ++ select: select, ++ slot: slot, ++ source: source$1, ++ style: style, ++ table: table, ++ tbody: tbody, ++ td: td, ++ textarea: textarea, ++ tfoot: tfoot, ++ th: th, ++ thead: thead, ++ time: time, ++ tr: tr, ++ track: track, ++ ul: ul, ++ video: video, ++ 'default': index$1 ++}); ++ ++var htmlTagNames$1 = getCjsExportFromNamespace(htmlTagNames); ++ ++var htmlElementAttributes$1 = getCjsExportFromNamespace(htmlElementAttributes); ++ ++const { ++ CSS_DISPLAY_TAGS, ++ CSS_DISPLAY_DEFAULT, ++ CSS_WHITE_SPACE_TAGS, ++ CSS_WHITE_SPACE_DEFAULT ++} = json$1; ++const HTML_TAGS = arrayToMap(htmlTagNames$1); ++const HTML_ELEMENT_ATTRIBUTES = mapObject(htmlElementAttributes$1, arrayToMap); ++ ++function arrayToMap(array) { ++ const map = Object.create(null); ++ ++ for (const value of array) { ++ map[value] = true; ++ } ++ ++ return map; ++} ++ ++function mapObject(object, fn) { ++ const newObject = Object.create(null); ++ ++ for (const key of Object.keys(object)) { ++ newObject[key] = fn(object[key], key); ++ } ++ ++ return newObject; ++} ++ ++function shouldPreserveContent(node, options) { ++ if (!node.endSourceSpan) { ++ return false; ++ } ++ ++ if (node.type === "element" && node.fullName === "template" && node.attrMap.lang && node.attrMap.lang !== "html") { ++ return true; ++ } // unterminated node in ie conditional comment ++ // e.g. ++ ++ ++ if (node.type === "ieConditionalComment" && node.lastChild && !node.lastChild.isSelfClosing && !node.lastChild.endSourceSpan) { ++ return true; ++ } // incomplete html in ie conditional comment ++ // e.g. ++ ++ ++ if (node.type === "ieConditionalComment" && !node.complete) { ++ return true; ++ } // top-level elements (excluding