Mar 25, 2021 · Jan 15, 2021 · Jan 15, 2021 · Jan 18, 2021 · Jan 19, 2021 · Jan 25, 2021
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
        "category": "Error",
        "code": 2802
    },
    "Cannot assign to private method '{0}'. Private methods are not writable.": {
        "category": "Error",
        "code": 2803
    },
    "Duplicate identifier '{0}'. Static and instance elements cannot share the same private name.": {
        "category": "Error",
        "code": 2804
    },
    "Static fields with private names can't have initializers when the '--useDefineForClassFields' flag is not specified with a '--target' of 'esnext'. Consider adding the '--useDefineForClassFields' flag.": {
        "category": "Error",
        "code": 2805
    },
    "Private accessor was defined without a getter.": {
        "category": "Error",
        "code": 2806
    },
    "This syntax requires an imported helper named '{1}' with {2} parameters, which is not compatible with the one in '{0}'. Consider upgrading your version of '{0}'.": {
        "category": "Error",
        "code": 2807
    },

    "Import declaration '{0}' is using private name '{1}'.": {
        "category": "Error",
        "category": "Error",
        "code": 18019
    },
    "A method cannot be named with a private identifier.": {
        "category": "Error",
        "code": 18022
    },
    "An accessor cannot be named with a private identifier.": {
        "category": "Error",
        "code": 18023
    },
    "An enum member cannot be named with a private identifier.": {
        "category": "Error",
        "code": 18024
    "Invalid value for 'jsxFragmentFactory'. '{0}' is not a valid identifier or qualified-name.": {
        "category": "Error",
        "code": 18035
    },
    "Class decorators can't be used with static private identifier. Consider removing the experimental decorator.": {
        "category": "Error",
        "code": 18036
    }
 }
diff --git a/src/compiler/factory/emitHelpers.ts b/src/compiler/factory/emitHelpers.ts
        createImportDefaultHelper(expression: Expression): Expression;
        createExportStarHelper(moduleExpression: Expression, exportsExpression?: Expression): Expression;
        // Class Fields Helpers
        createClassPrivateFieldGetHelper(receiver: Expression,privateField: Identifier): Expression;
        createClassPrivateFieldSetHelper(receiver: Expression,privateField: Identifier, value: Expression): Expression;
        createClassPrivateFieldGetHelper(receiver: Expression,state: Identifier, kind: PrivateIdentifierKind, f: Identifier | undefined): Expression;
        createClassPrivateFieldSetHelper(receiver: Expression,state: Identifier, value: Expression, kind: PrivateIdentifierKind, f: Identifier | undefined): Expression;
    }

    export function createEmitHelperFactory(context: TransformationContext): EmitHelperFactory {

        // Class Fields Helpers

        function createClassPrivateFieldGetHelper(receiver: Expression,privateField: Identifier) {
        function createClassPrivateFieldGetHelper(receiver: Expression,state: Identifier, kind: PrivateIdentifierKind, f: Identifier | undefined) {
            context.requestEmitHelper(classPrivateFieldGetHelper);
            return factory.createCallExpression(getUnscopedHelperName("__classPrivateFieldGet"), /*typeArguments*/ undefined, [receiver, privateField]);
            let args;
            if (!f) {
                args = [receiver, state, factory.createStringLiteral(kind)];
            }
            else {
                args = [receiver, state, factory.createStringLiteral(kind), f];
            }
            return factory.createCallExpression(getUnscopedHelperName("__classPrivateFieldGet"), /*typeArguments*/ undefined, args);
        }

        function createClassPrivateFieldSetHelper(receiver: Expression,privateField: Identifier, value: Expression) {
        function createClassPrivateFieldSetHelper(receiver: Expression,state: Identifier, value: Expression, kind: PrivateIdentifierKind, f: Identifier | undefined) {
            context.requestEmitHelper(classPrivateFieldSetHelper);
            return factory.createCallExpression(getUnscopedHelperName("__classPrivateFieldSet"), /*typeArguments*/ undefined, [receiver, privateField, value]);
            let args;
            if (!f) {
                args = [receiver, state, value, factory.createStringLiteral(kind)];
            }
            else {
                args = [receiver, state, value, factory.createStringLiteral(kind), f];
            }
            return factory.createCallExpression(getUnscopedHelperName("__classPrivateFieldSet"), /*typeArguments*/ undefined, args);
        }

    }

    /* @internal */
            };`
    };

    // emit output for the __export helper function
    export const exportStarHelper: UnscopedEmitHelper = {
        name: "typescript:export-star",
        importName: "__exportStar",
            };`
    };

    // Class fields helpers
    /**
     * Parameters:
     *  @param receiver — The object from which the private member will be read.
     *  @param state — One of the following:
     *      - A WeakMap used to read a private instance field.
     *      - A WeakSet used as an instance brand for private instance methods and accessors.
     *      - A function value that should be the undecorated class constructor used to brand check private static fields, methods, and accessors.
     *  @param kind — (optional pre TS 4.3, required for TS 4.3+) One of the following values:
     *      - undefined — Indicates a private instance field (pre TS 4.3).
     *      - "f" — Indicates a private field (instance or static).
     *      - "m" — Indicates a private method (instance or static).
     *      - "a" — Indicates a private accessor (instance or static).
     *  @param f — (optional pre TS 4.3) Depends on the arguments for state and kind:
     *      - If kind is "m", this should be the function corresponding to the static or instance method.
     *      - If kind is "a", this should be the function corresponding to the getter method, or undefined if the getter was not defined.
     *      - If kind is "f" and state is a function, this should be an object holding the value of a static field, or undefined if the static field declaration has not yet been evaluated.
     * Usage:
     * This helper will only ever be used by the compiler in the following ways:
     *
     * Reading from a private instance field (pre TS 4.3):
     *      __classPrivateFieldGet(<any>, <WeakMap>)
     *
     * Reading from a private instance field (TS 4.3+):
     *      __classPrivateFieldGet(<any>, <WeakMap>, "f")
     *
     * Reading from a private instance get accessor (when defined, TS 4.3+):
     *      __classPrivateFieldGet(<any>, <WeakSet>, "a", <function>)
     *
     * Reading from a private instance get accessor (when not defined, TS 4.3+):
     *      __classPrivateFieldGet(<any>, <WeakSet>, "a", void 0)
     *      NOTE: This always results in a runtime error.
     *
     * Reading from a private instance method (TS 4.3+):
     *      __classPrivateFieldGet(<any>, <WeakSet>, "m", <function>)
     *
     * Reading from a private static field (TS 4.3+):
     *      __classPrivateFieldGet(<any>, <constructor>, "f", <{ value: any }>)
     *
     * Reading from a private static get accessor (when defined, TS 4.3+):
     *      __classPrivateFieldGet(<any>, <constructor>, "a", <function>)
     *
     * Reading from a private static get accessor (when not defined, TS 4.3+):
     *      __classPrivateFieldGet(<any>, <constructor>, "a", void 0)
     *      NOTE: This always results in a runtime error.
     *
     * Reading from a private static method (TS 4.3+):
     *      __classPrivateFieldGet(<any>, <constructor>, "m", <function>)
     */
    export const classPrivateFieldGetHelper: UnscopedEmitHelper = {
        name: "typescript:classPrivateFieldGet",
        importName: "__classPrivateFieldGet",
        scoped: false,
        text: `
            var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
                if (!privateMap.has(receiver)) {
                    throw new TypeError("attempted to get private field on non-instance");
                }
                return privateMap.get(receiver);
            var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
                if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
                if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
                return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
            };`
    };

    /**
     * Parameters:
     *  @param receiver — The object on which the private member will be set.
     *  @param state — One of the following:
     *      - A WeakMap used to store a private instance field.
     *      - A WeakSet used as an instance brand for private instance methods and accessors.
     *      - A function value that should be the undecorated class constructor used to brand check private static fields, methods, and accessors.
     *  @param value — The value to set.
     *  @param kind — (optional pre TS 4.3, required for TS 4.3+) One of the following values:
     *       - undefined — Indicates a private instance field (pre TS 4.3).
     *       - "f" — Indicates a private field (instance or static).
     *       - "m" — Indicates a private method (instance or static).
     *       - "a" — Indicates a private accessor (instance or static).
     *   @param f — (optional pre TS 4.3) Depends on the arguments for state and kind:
     *       - If kind is "m", this should be the function corresponding to the static or instance method.
     *       - If kind is "a", this should be the function corresponding to the setter method, or undefined if the setter was not defined.
     *       - If kind is "f" and state is a function, this should be an object holding the value of a static field, or undefined if the static field declaration has not yet been evaluated.
     * Usage:
     * This helper will only ever be used by the compiler in the following ways:
     *
     * Writing to a private instance field (pre TS 4.3):
     *      __classPrivateFieldSet(<any>, <WeakMap>, <any>)
     *
     * Writing to a private instance field (TS 4.3+):
     *      __classPrivateFieldSet(<any>, <WeakMap>, <any>, "f")
     *
     * Writing to a private instance set accessor (when defined, TS 4.3+):
     *      __classPrivateFieldSet(<any>, <WeakSet>, <any>, "a", <function>)
     *
     * Writing to a private instance set accessor (when not defined, TS 4.3+):
     *      __classPrivateFieldSet(<any>, <WeakSet>, <any>, "a", void 0)
     *      NOTE: This always results in a runtime error.
     *
     * Writing to a private instance method (TS 4.3+):
     *      __classPrivateFieldSet(<any>, <WeakSet>, <any>, "m", <function>)
     *      NOTE: This always results in a runtime error.
     *
     * Writing to a private static field (TS 4.3+):
     *      __classPrivateFieldSet(<any>, <constructor>, <any>, "f", <{ value: any }>)
     *
     * Writing to a private static set accessor (when defined, TS 4.3+):
     *      __classPrivateFieldSet(<any>, <constructor>, <any>, "a", <function>)
     *
     * Writing to a private static set accessor (when not defined, TS 4.3+):
     *      __classPrivateFieldSet(<any>, <constructor>, <any>, "a", void 0)
     *      NOTE: This always results in a runtime error.
     *
     * Writing to a private static method (TS 4.3+):
     *      __classPrivateFieldSet(<any>, <constructor>, <any>, "m", <function>)
     *      NOTE: This always results in a runtime error.
     */
    export const classPrivateFieldSetHelper: UnscopedEmitHelper = {
        name: "typescript:classPrivateFieldSet",
        importName: "__classPrivateFieldSet",
        scoped: false,
        text: `
            var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
                if (!privateMap.has(receiver)) {
                    throw new TypeError("attempted to set private field on non-instance");
                }
                privateMap.set(receiver, value);
                return value;
            var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
                if (kind === "m") throw new TypeError("Private method is not writable");
                if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
                if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
                return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
            };`
    };

            && (getEmitFlags(firstSegment.expression) & EmitFlags.HelperName)
            && firstSegment.expression.escapedText === helperName;
    }
 }
 }
Original file line number	Diff line number	Diff line change
Expand Up		@@ -3284,6 +3284,26 @@
		"category": "Error",
		"code": 2802
		},
		"Cannot assign to private method '{0}'. Private methods are not writable.": {
		"category": "Error",
		"code": 2803
		},
		"Duplicate identifier '{0}'. Static and instance elements cannot share the same private name.": {
		"category": "Error",
		"code": 2804
		},
		"Static fields with private names can't have initializers when the '--useDefineForClassFields' flag is not specified with a '--target' of 'esnext'. Consider adding the '--useDefineForClassFields' flag.": {
		"category": "Error",
		"code": 2805
		},
		"Private accessor was defined without a getter.": {
		"category": "Error",
		"code": 2806
		},
		"This syntax requires an imported helper named '{1}' with {2} parameters, which is not compatible with the one in '{0}'. Consider upgrading your version of '{0}'.": {
		"category": "Error",
		"code": 2807
		},

		"Import declaration '{0}' is using private name '{1}'.": {
		"category": "Error",
Expand DownExpand Up		@@ -6334,14 +6354,6 @@
		"category": "Error",
		"code": 18019
		},
		"A method cannot be named with a private identifier.": {
		"category": "Error",
		"code": 18022
		},
		"An accessor cannot be named with a private identifier.": {
		"category": "Error",
		"code": 18023
		},
		"An enum member cannot be named with a private identifier.": {
		"category": "Error",
		"code": 18024
Expand DownExpand Up		@@ -6385,5 +6397,9 @@
		"Invalid value for 'jsxFragmentFactory'. '{0}' is not a valid identifier or qualified-name.": {
		"category": "Error",
		"code": 18035
		},
		"Class decorators can't be used with static private identifier. Consider removing the experimental decorator.": {
		"category": "Error",
		"code": 18036
		}
		}
Original file line number	Diff line number	Diff line change
Expand Up		@@ -32,8 +32,8 @@ namespace ts {
		createImportDefaultHelper(expression: Expression): Expression;
		createExportStarHelper(moduleExpression: Expression, exportsExpression?: Expression): Expression;
		// Class Fields Helpers
		createClassPrivateFieldGetHelper(receiver: Expression,privateField: Identifier): Expression;
		createClassPrivateFieldSetHelper(receiver: Expression,privateField: Identifier, value: Expression): Expression;
		createClassPrivateFieldGetHelper(receiver: Expression,state: Identifier, kind: PrivateIdentifierKind, f: Identifier \| undefined): Expression;
Copy link Contributor rbucktonMar 23, 2021 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. We may need a test in checker that verifies the parameter count of`__classPrivateFieldGet` and`__classPrivateFieldSet` using the .d.ts we ship with tslib to verify you're using an up-to-date version of tslib. Copy link Contributor mkubilaykMar 23, 2021 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. I see`checkExternalEmitHelpers` is used to check the existence of helpers. Were you thinking an extension to that, which would validate the parameter count for`ExternalEmitHelpers.ClassPrivateFieldGet \| ExternalEmitHelpers.ClassPrivateFieldSet`? Copy link Contributor mkubilaykMar 23, 2021 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. Added this in`7d8a2b9`. Copy link Contributor rbucktonMar 24, 2021 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. [...] Were you thinking an extension to that, which would validate the parameter count for`ExternalEmitHelpers.ClassPrivateFieldGet \| ExternalEmitHelpers.ClassPrivateFieldSet`? That's precisely what I was describing, yes. mkubilayk reacted with thumbs up emoji
		createClassPrivateFieldSetHelper(receiver: Expression,state: Identifier, value: Expression, kind: PrivateIdentifierKind, f: Identifier \| undefined): Expression;
		}

		export function createEmitHelperFactory(context: TransformationContext): EmitHelperFactory {
Expand DownExpand Up		@@ -368,15 +368,30 @@ namespace ts {

		// Class Fields Helpers

		function createClassPrivateFieldGetHelper(receiver: Expression,privateField: Identifier) {
		function createClassPrivateFieldGetHelper(receiver: Expression,state: Identifier, kind: PrivateIdentifierKind, f: Identifier \| undefined) {
		context.requestEmitHelper(classPrivateFieldGetHelper);
		return factory.createCallExpression(getUnscopedHelperName("__classPrivateFieldGet"), /typeArguments/ undefined, [receiver, privateField]);
		let args;
		if (!f) {
		args = [receiver, state, factory.createStringLiteral(kind)];
		}
		else {
		args = [receiver, state, factory.createStringLiteral(kind), f];
		}
		return factory.createCallExpression(getUnscopedHelperName("__classPrivateFieldGet"), /typeArguments/ undefined, args);
		}

		function createClassPrivateFieldSetHelper(receiver: Expression,privateField: Identifier, value: Expression) {
		function createClassPrivateFieldSetHelper(receiver: Expression,state: Identifier, value: Expression, kind: PrivateIdentifierKind, f: Identifier \| undefined) {
		context.requestEmitHelper(classPrivateFieldSetHelper);
		return factory.createCallExpression(getUnscopedHelperName("__classPrivateFieldSet"), /typeArguments/ undefined, [receiver, privateField, value]);
		let args;
		if (!f) {
		args = [receiver, state, value, factory.createStringLiteral(kind)];
		}
		else {
		args = [receiver, state, value, factory.createStringLiteral(kind), f];
		}
		return factory.createCallExpression(getUnscopedHelperName("__classPrivateFieldSet"), /typeArguments/ undefined, args);
		}

		}

		/* @internal */
Expand DownExpand Up		@@ -803,7 +818,6 @@ namespace ts {
		};`
		};

		// emit output for the __export helper function
		export const exportStarHelper: UnscopedEmitHelper = {
		name: "typescript:export-star",
		importName: "__exportStar",
Expand All		@@ -816,31 +830,127 @@ namespace ts {
		};`
		};

		// Class fields helpers
		/**
		* Parameters:
		* @param receiver — The object from which the private member will be read.
		* @param state — One of the following:
		* - A WeakMap used to read a private instance field.
		* - A WeakSet used as an instance brand for private instance methods and accessors.
		* - A function value that should be the undecorated class constructor used to brand check private static fields, methods, and accessors.
		* @param kind — (optional pre TS 4.3, required for TS 4.3+) One of the following values:
		* - undefined — Indicates a private instance field (pre TS 4.3).
		* - "f" — Indicates a private field (instance or static).
		* - "m" — Indicates a private method (instance or static).
		* - "a" — Indicates a private accessor (instance or static).
		* @param f — (optional pre TS 4.3) Depends on the arguments for state and kind:
		* - If kind is "m", this should be the function corresponding to the static or instance method.
		* - If kind is "a", this should be the function corresponding to the getter method, or undefined if the getter was not defined.
		* - If kind is "f" and state is a function, this should be an object holding the value of a static field, or undefined if the static field declaration has not yet been evaluated.
		* Usage:
		* This helper will only ever be used by the compiler in the following ways:
		*
		* Reading from a private instance field (pre TS 4.3):
		* __classPrivateFieldGet(<any>, <WeakMap>)
		*
		* Reading from a private instance field (TS 4.3+):
		* __classPrivateFieldGet(<any>, <WeakMap>, "f")
		*
		* Reading from a private instance get accessor (when defined, TS 4.3+):
		* __classPrivateFieldGet(<any>, <WeakSet>, "a", <function>)
		*
		* Reading from a private instance get accessor (when not defined, TS 4.3+):
		* __classPrivateFieldGet(<any>, <WeakSet>, "a", void 0)
		* NOTE: This always results in a runtime error.
		*
		* Reading from a private instance method (TS 4.3+):
		* __classPrivateFieldGet(<any>, <WeakSet>, "m", <function>)
		*
		* Reading from a private static field (TS 4.3+):
		* __classPrivateFieldGet(<any>, <constructor>, "f", <{ value: any }>)
		*
		* Reading from a private static get accessor (when defined, TS 4.3+):
		* __classPrivateFieldGet(<any>, <constructor>, "a", <function>)
		*
		* Reading from a private static get accessor (when not defined, TS 4.3+):
		* __classPrivateFieldGet(<any>, <constructor>, "a", void 0)
		* NOTE: This always results in a runtime error.
		*
		* Reading from a private static method (TS 4.3+):
		* __classPrivateFieldGet(<any>, <constructor>, "m", <function>)
		*/
		export const classPrivateFieldGetHelper: UnscopedEmitHelper = {
		name: "typescript:classPrivateFieldGet",
		importName: "__classPrivateFieldGet",
		scoped: false,
		text: `
		var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) \|\| function (receiver, privateMap) {
		if (!privateMap.has(receiver)) {
		throw new TypeError("attempted to get private field on non-instance");
		}
		return privateMap.get(receiver);
		var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) \|\| function (receiver, state, kind, f) {
		if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
		if (typeof state === "function" ? receiver !== state \|\| !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
		return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
		};`
		};

		/**
		* Parameters:
		* @param receiver — The object on which the private member will be set.
		* @param state — One of the following:
		* - A WeakMap used to store a private instance field.
		* - A WeakSet used as an instance brand for private instance methods and accessors.
		* - A function value that should be the undecorated class constructor used to brand check private static fields, methods, and accessors.
		* @param value — The value to set.
		* @param kind — (optional pre TS 4.3, required for TS 4.3+) One of the following values:
		* - undefined — Indicates a private instance field (pre TS 4.3).
		* - "f" — Indicates a private field (instance or static).
		* - "m" — Indicates a private method (instance or static).
		* - "a" — Indicates a private accessor (instance or static).
		* @param f — (optional pre TS 4.3) Depends on the arguments for state and kind:
		* - If kind is "m", this should be the function corresponding to the static or instance method.
		* - If kind is "a", this should be the function corresponding to the setter method, or undefined if the setter was not defined.
		* - If kind is "f" and state is a function, this should be an object holding the value of a static field, or undefined if the static field declaration has not yet been evaluated.
		* Usage:
		* This helper will only ever be used by the compiler in the following ways:
		*
		* Writing to a private instance field (pre TS 4.3):
		* __classPrivateFieldSet(<any>, <WeakMap>, <any>)
		*
		* Writing to a private instance field (TS 4.3+):
		* __classPrivateFieldSet(<any>, <WeakMap>, <any>, "f")
		*
		* Writing to a private instance set accessor (when defined, TS 4.3+):
		* __classPrivateFieldSet(<any>, <WeakSet>, <any>, "a", <function>)
		*
		* Writing to a private instance set accessor (when not defined, TS 4.3+):
		* __classPrivateFieldSet(<any>, <WeakSet>, <any>, "a", void 0)
		* NOTE: This always results in a runtime error.
		*
		* Writing to a private instance method (TS 4.3+):
		* __classPrivateFieldSet(<any>, <WeakSet>, <any>, "m", <function>)
		* NOTE: This always results in a runtime error.
		*
		* Writing to a private static field (TS 4.3+):
		* __classPrivateFieldSet(<any>, <constructor>, <any>, "f", <{ value: any }>)
		*
		* Writing to a private static set accessor (when defined, TS 4.3+):
		* __classPrivateFieldSet(<any>, <constructor>, <any>, "a", <function>)
		*
		* Writing to a private static set accessor (when not defined, TS 4.3+):
		* __classPrivateFieldSet(<any>, <constructor>, <any>, "a", void 0)
		* NOTE: This always results in a runtime error.
		*
		* Writing to a private static method (TS 4.3+):
		* __classPrivateFieldSet(<any>, <constructor>, <any>, "m", <function>)
		* NOTE: This always results in a runtime error.
		*/
		export const classPrivateFieldSetHelper: UnscopedEmitHelper = {
		name: "typescript:classPrivateFieldSet",
		importName: "__classPrivateFieldSet",
		scoped: false,
		text: `
		var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) \|\| function (receiver, privateMap, value) {
		if (!privateMap.has(receiver)) {
		throw new TypeError("attempted to set private field on non-instance");
		}
		privateMap.set(receiver, value);
		return value;
		var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) \|\| function (receiver, state, value, kind, f) {
		if (kind === "m") throw new TypeError("Private method is not writable");
		if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
		if (typeof state === "function" ? receiver !== state \|\| !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
		return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
		};`
		};

Expand DownExpand Up		@@ -897,4 +1007,4 @@ namespace ts {
		&& (getEmitFlags(firstSegment.expression) & EmitFlags.HelperName)
		&& firstSegment.expression.escapedText === helperName;
		}
		}
		}