js/experimental/runtime/internal/checks.js - third_party/protobuf - Git at Google

 /**
  * @fileoverview Proto internal runtime checks.
  *
  * Checks are grouped into different severity, see:
  * http://g3doc/third_party/protobuf/javascript/README.md#configurable-check-support-in-protocol-buffers
  *
  * Checks are also grouped into different sections:
  *   - CHECK_BOUNDS:
  *       Checks that ensure that indexed access is within bounds
  *       (e.g. an array being accessed past its size).
  *   - CHECK_STATE
  *       Checks related to the state of an object
  *       (e.g. a parser hitting an invalid case).
  *   - CHECK_TYPE:
  *       Checks that relate to type errors (e.g. code receives a number instead
  *       of a string).
  */
 goog.module('protobuf.internal.checks');

 const ByteString = goog.require('protobuf.ByteString');
 const Int64 = goog.require('protobuf.Int64');
 const WireType = goog.require('protobuf.binary.WireType');

 //
 // See
 // http://g3doc/third_party/protobuf/javascript/README.md#configurable-check-support-in-protocol-buffers
 //
 /** @define{string} */
 const CHECK_LEVEL_DEFINE = goog.define('protobuf.defines.CHECK_LEVEL', '');

 /** @define{boolean} */
 const POLYFILL_TEXT_ENCODING =
     goog.define('protobuf.defines.POLYFILL_TEXT_ENCODING', true);

 /**
  * @const {number}
  */
 const MAX_FIELD_NUMBER = Math.pow(2, 29) - 1;

 /**
  * The largest finite float32 value.
  * @const {number}
  */
 const FLOAT32_MAX = 3.4028234663852886e+38;

 /** @enum {number} */
 const CheckLevel = {
   DEBUG: 0,
   CRITICAL: 1,
   OFF: 2
 };


 /** @return {!CheckLevel} */
 function calculateCheckLevel() {
   const definedLevel = CHECK_LEVEL_DEFINE.toUpperCase();
   if (definedLevel === '') {
     // user did not set a value, value now just depends on goog.DEBUG
     return goog.DEBUG ? CheckLevel.DEBUG : CheckLevel.CRITICAL;
   }

   if (definedLevel === 'CRITICAL') {
     return CheckLevel.CRITICAL;
   }

   if (definedLevel === 'OFF') {
     return CheckLevel.OFF;
   }

   if (definedLevel === 'DEBUG') {
     return CheckLevel.DEBUG;
   }

   throw new Error(`Unknown value for CHECK_LEVEL: ${CHECK_LEVEL_DEFINE}`);
 }

 const /** !CheckLevel */ CHECK_LEVEL = calculateCheckLevel();

 const /** boolean */ CHECK_STATE = CHECK_LEVEL === CheckLevel.DEBUG;

 const /** boolean */ CHECK_CRITICAL_STATE =
     CHECK_LEVEL === CheckLevel.CRITICAL || CHECK_LEVEL === CheckLevel.DEBUG;

 const /** boolean */ CHECK_BOUNDS = CHECK_LEVEL === CheckLevel.DEBUG;

 const /** boolean */ CHECK_CRITICAL_BOUNDS =
     CHECK_LEVEL === CheckLevel.CRITICAL || CHECK_LEVEL === CheckLevel.DEBUG;

 const /** boolean */ CHECK_TYPE = CHECK_LEVEL === CheckLevel.DEBUG;

 const /** boolean */ CHECK_CRITICAL_TYPE =
     CHECK_LEVEL === CheckLevel.CRITICAL || CHECK_LEVEL === CheckLevel.DEBUG;

 /**
  * Ensures the truth of an expression involving the state of the calling
  * instance, but not involving any parameters to the calling method.
  *
  * For cases where failing fast is pretty important and not failing early could
  * cause bugs that are much harder to debug.
  * @param {boolean} state
  * @param {string=} message
  * @throws {!Error} If the state is false and the check state is critical.
  */
 function checkCriticalState(state, message = '') {
   if (!CHECK_CRITICAL_STATE) {
     return;
   }
   if (!state) {
     throw new Error(message);
   }
 }

 /**
  * Ensures the truth of an expression involving the state of the calling
  * instance, but not involving any parameters to the calling method.
  *
  * @param {boolean} state
  * @param {string=} message
  * @throws {!Error} If the state is false and the check state is debug.
  */
 function checkState(state, message = '') {
   if (!CHECK_STATE) {
     return;
   }
   checkCriticalState(state, message);
 }

 /**
  * Ensures that `index` specifies a valid position in an indexable object of
  * size `size`. A position index may range from zero to size, inclusive.
  * @param {number} index
  * @param {number} size
  * @throws {!Error} If the index is out of range and the check state is debug.
  */
 function checkPositionIndex(index, size) {
   if (!CHECK_BOUNDS) {
     return;
   }
   checkCriticalPositionIndex(index, size);
 }

 /**
  * Ensures that `index` specifies a valid position in an indexable object of
  * size `size`. A position index may range from zero to size, inclusive.
  * @param {number} index
  * @param {number} size
  * @throws {!Error} If the index is out of range and the check state is
  * critical.
  */
 function checkCriticalPositionIndex(index, size) {
   if (!CHECK_CRITICAL_BOUNDS) {
     return;
   }
   if (index < 0 || index > size) {
     throw new Error(`Index out of bounds: index: ${index} size: ${size}`);
   }
 }

 /**
  * Ensures that `index` specifies a valid element in an indexable object of
  * size `size`. A element index may range from zero to size, exclusive.
  * @param {number} index
  * @param {number} size
  * @throws {!Error} If the index is out of range and the check state is
  * debug.
  */
 function checkElementIndex(index, size) {
   if (!CHECK_BOUNDS) {
     return;
   }
   checkCriticalElementIndex(index, size);
 }

 /**
  * Ensures that `index` specifies a valid element in an indexable object of
  * size `size`. A element index may range from zero to size, exclusive.
  * @param {number} index
  * @param {number} size
  * @throws {!Error} If the index is out of range and the check state is
  * critical.
  */
 function checkCriticalElementIndex(index, size) {
   if (!CHECK_CRITICAL_BOUNDS) {
     return;
   }
   if (index < 0 || index >= size) {
     throw new Error(`Index out of bounds: index: ${index} size: ${size}`);
   }
 }

 /**
  * Ensures the range of [start, end) is with the range of [0, size).
  * @param {number} start
  * @param {number} end
  * @param {number} size
  * @throws {!Error} If start and end are out of range and the check state is
  * debug.
  */
 function checkRange(start, end, size) {
   if (!CHECK_BOUNDS) {
     return;
   }
   checkCriticalRange(start, end, size);
 }

 /**
  * Ensures the range of [start, end) is with the range of [0, size).
  * @param {number} start
  * @param {number} end
  * @param {number} size
  * @throws {!Error} If start and end are out of range and the check state is
  * critical.
  */
 function checkCriticalRange(start, end, size) {
   if (!CHECK_CRITICAL_BOUNDS) {
     return;
   }
   if (start < 0 || end < 0 || start > size || end > size) {
     throw new Error(`Range error: start: ${start} end: ${end} size: ${size}`);
   }
   if (start > end) {
     throw new Error(`Start > end: ${start} > ${end}`);
   }
 }

 /**
  * Ensures that field number is an integer and within the range of
  * [1, MAX_FIELD_NUMBER].
  * @param {number} fieldNumber
  * @throws {!Error} If the field number is out of range and the check state is
  * debug.
  */
 function checkFieldNumber(fieldNumber) {
   if (!CHECK_TYPE) {
     return;
   }
   checkCriticalFieldNumber(fieldNumber);
 }

 /**
  * Ensures that the value is neither null nor undefined.
  *
  * @param {T} value
  * @return {R}
  *
  * @template T
  * @template R :=
  *     mapunion(T, (V) =>
  *         cond(eq(V, 'null'),
  *             none(),
  *             cond(eq(V, 'undefined'),
  *                 none(),
  *                 V)))
  *  =:
  */
 function checkDefAndNotNull(value) {
   if (CHECK_TYPE) {
     // Note that undefined == null.
     if (value == null) {
       throw new Error(`Value can't be null`);
     }
   }
   return value;
 }

 /**
  * Ensures that the value exists and is a function.
  *
  * @param {function(?): ?} func
  */
 function checkFunctionExists(func) {
   if (CHECK_TYPE) {
     if (typeof func !== 'function') {
       throw new Error(`${func} is not a function`);
     }
   }
 }

 /**
  * Ensures that field number is an integer and within the range of
  * [1, MAX_FIELD_NUMBER].
  * @param {number} fieldNumber
  * @throws {!Error} If the field number is out of range and the check state is
  * critical.
  */
 function checkCriticalFieldNumber(fieldNumber) {
   if (!CHECK_CRITICAL_TYPE) {
     return;
   }
   if (fieldNumber <= 0 || fieldNumber > MAX_FIELD_NUMBER) {
     throw new Error(`Field number is out of range: ${fieldNumber}`);
   }
 }

 /**
  * Ensures that wire type is valid.
  * @param {!WireType} wireType
  * @throws {!Error} If the wire type is invalid and the check state is debug.
  */
 function checkWireType(wireType) {
   if (!CHECK_TYPE) {
     return;
   }
   checkCriticalWireType(wireType);
 }

 /**
  * Ensures that wire type is valid.
  * @param {!WireType} wireType
  * @throws {!Error} If the wire type is invalid and the check state is critical.
  */
 function checkCriticalWireType(wireType) {
   if (!CHECK_CRITICAL_TYPE) {
     return;
   }
   if (wireType < WireType.VARINT || wireType > WireType.FIXED32) {
     throw new Error(`Invalid wire type: ${wireType}`);
   }
 }

 /**
  * Ensures the given value has the correct type.
  * @param {boolean} expression
  * @param {string} errorMsg
  * @throws {!Error} If the value has the wrong type and the check state is
  * critical.
  */
 function checkCriticalType(expression, errorMsg) {
   if (!CHECK_CRITICAL_TYPE) {
     return;
   }
   if (!expression) {
     throw new Error(errorMsg);
   }
 }

 /**
  * Checks whether a given object is an array.
  * @param {*} value
  * @return {!Array<*>}
  */
 function checkCriticalTypeArray(value) {
   checkCriticalType(
       Array.isArray(value), `Must be an array, but got: ${value}`);
   return /** @type {!Array<*>} */ (value);
 }

 /**
  * Checks whether a given object is an iterable.
  * @param {*} value
  * @return {!Iterable<*>}
  */
 function checkCriticalTypeIterable(value) {
   checkCriticalType(
       !!value[Symbol.iterator], `Must be an iterable, but got: ${value}`);
   return /** @type {!Iterable<*>} */ (value);
 }

 /**
  * Checks whether a given object is a boolean.
  * @param {*} value
  */
 function checkCriticalTypeBool(value) {
   checkCriticalType(
       typeof value === 'boolean', `Must be a boolean, but got: ${value}`);
 }

 /**
  * Checks whether a given object is an array of boolean.
  * @param {*} values
  */
 function checkCriticalTypeBoolArray(values) {
   // TODO(b/134765672)
   if (!CHECK_CRITICAL_TYPE) {
     return;
   }
   const array = checkCriticalTypeArray(values);
   for (const value of array) {
     checkCriticalTypeBool(value);
   }
 }

 /**
  * Checks whether a given object is a ByteString.
  * @param {*} value
  */
 function checkCriticalTypeByteString(value) {
   checkCriticalType(
       value instanceof ByteString, `Must be a ByteString, but got: ${value}`);
 }

 /**
  * Checks whether a given object is an array of ByteString.
  * @param {*} values
  */
 function checkCriticalTypeByteStringArray(values) {
   // TODO(b/134765672)
   if (!CHECK_CRITICAL_TYPE) {
     return;
   }
   const array = checkCriticalTypeArray(values);
   for (const value of array) {
     checkCriticalTypeByteString(value);
   }
 }

 /**
  * Checks whether a given object is a number.
  * @param {*} value
  * @throws {!Error} If the value is not float and the check state is debug.
  */
 function checkTypeDouble(value) {
   if (!CHECK_TYPE) {
     return;
   }
   checkCriticalTypeDouble(value);
 }

 /**
  * Checks whether a given object is a number.
  * @param {*} value
  * @throws {!Error} If the value is not float and the check state is critical.
  */
 function checkCriticalTypeDouble(value) {
   checkCriticalType(
       typeof value === 'number', `Must be a number, but got: ${value}`);
 }

 /**
  * Checks whether a given object is an array of double.
  * @param {*} values
  */
 function checkCriticalTypeDoubleArray(values) {
   // TODO(b/134765672)
   if (!CHECK_CRITICAL_TYPE) {
     return;
   }
   const array = checkCriticalTypeArray(values);
   for (const value of array) {
     checkCriticalTypeDouble(value);
   }
 }

 /**
  * Checks whether a given object is a number.
  * @param {*} value
  * @throws {!Error} If the value is not signed int32 and the check state is
  *     debug.
  */
 function checkTypeSignedInt32(value) {
   if (!CHECK_TYPE) {
     return;
   }
   checkCriticalTypeSignedInt32(value);
 }

 /**
  * Checks whether a given object is a number.
  * @param {*} value
  * @throws {!Error} If the value is not signed int32 and the check state is
  *     critical.
  */
 function checkCriticalTypeSignedInt32(value) {
   checkCriticalTypeDouble(value);
   const valueAsNumber = /** @type {number} */ (value);
   if (CHECK_CRITICAL_TYPE) {
     if (valueAsNumber < -Math.pow(2, 31) || valueAsNumber > Math.pow(2, 31) ||
         !Number.isInteger(valueAsNumber)) {
       throw new Error(`Must be int32, but got: ${valueAsNumber}`);
     }
   }
 }

 /**
  * Checks whether a given object is an array of numbers.
  * @param {*} values
  */
 function checkCriticalTypeSignedInt32Array(values) {
   // TODO(b/134765672)
   if (!CHECK_CRITICAL_TYPE) {
     return;
   }
   const array = checkCriticalTypeArray(values);
   for (const value of array) {
     checkCriticalTypeSignedInt32(value);
   }
 }

 /**
  * Ensures that value is a long instance.
  * @param {*} value
  * @throws {!Error} If the value is not a long instance and check state is
  *     debug.
  */
 function checkTypeSignedInt64(value) {
   if (!CHECK_TYPE) {
     return;
   }
   checkCriticalTypeSignedInt64(value);
 }

 /**
  * Ensures that value is a long instance.
  * @param {*} value
  * @throws {!Error} If the value is not a long instance and check state is
  *     critical.
  */
 function checkCriticalTypeSignedInt64(value) {
   if (!CHECK_CRITICAL_TYPE) {
     return;
   }
   if (!(value instanceof Int64)) {
     throw new Error(`Must be Int64 instance, but got: ${value}`);
   }
 }

 /**
  * Checks whether a given object is an array of long instances.
  * @param {*} values
  * @throws {!Error} If values is not an array of long instances.
  */
 function checkCriticalTypeSignedInt64Array(values) {
   // TODO(b/134765672)
   if (!CHECK_CRITICAL_TYPE) {
     return;
   }
   const array = checkCriticalTypeArray(values);
   for (const value of array) {
     checkCriticalTypeSignedInt64(value);
   }
 }

 /**
  * Checks whether a given object is a number and within float32 precision.
  * @param {*} value
  * @throws {!Error} If the value is not float and the check state is debug.
  */
 function checkTypeFloat(value) {
   if (!CHECK_TYPE) {
     return;
   }
   checkCriticalTypeFloat(value);
 }

 /**
  * Checks whether a given object is a number and within float32 precision.
  * @param {*} value
  * @throws {!Error} If the value is not float and the check state is critical.
  */
 function checkCriticalTypeFloat(value) {
   checkCriticalTypeDouble(value);
   if (CHECK_CRITICAL_TYPE) {
     const valueAsNumber = /** @type {number} */ (value);
     if (Number.isFinite(valueAsNumber) &&
         (valueAsNumber > FLOAT32_MAX || valueAsNumber < -FLOAT32_MAX)) {
       throw new Error(
           `Given number does not fit into float precision: ${value}`);
     }
   }
 }

 /**
  * Checks whether a given object is an iterable of floats.
  * @param {*} values
  */
 function checkCriticalTypeFloatIterable(values) {
   // TODO(b/134765672)
   if (!CHECK_CRITICAL_TYPE) {
     return;
   }
   const iterable = checkCriticalTypeIterable(values);
   for (const value of iterable) {
     checkCriticalTypeFloat(value);
   }
 }

 /**
  * Checks whether a given object is a string.
  * @param {*} value
  */
 function checkCriticalTypeString(value) {
   checkCriticalType(
       typeof value === 'string', `Must be string, but got: ${value}`);
 }

 /**
  * Checks whether a given object is an array of string.
  * @param {*} values
  */
 function checkCriticalTypeStringArray(values) {
   // TODO(b/134765672)
   if (!CHECK_CRITICAL_TYPE) {
     return;
   }
   const array = checkCriticalTypeArray(values);
   for (const value of array) {
     checkCriticalTypeString(value);
   }
 }

 /**
  * Ensures that value is a valid unsigned int32.
  * @param {*} value
  * @throws {!Error} If the value is out of range and the check state is debug.
  */
 function checkTypeUnsignedInt32(value) {
   if (!CHECK_TYPE) {
     return;
   }
   checkCriticalTypeUnsignedInt32(value);
 }

 /**
  * Ensures that value is a valid unsigned int32.
  * @param {*} value
  * @throws {!Error} If the value is out of range and the check state
  * is critical.
  */
 function checkCriticalTypeUnsignedInt32(value) {
   if (!CHECK_CRITICAL_TYPE) {
     return;
   }
   checkCriticalTypeDouble(value);
   const valueAsNumber = /** @type {number} */ (value);
   if (valueAsNumber < 0 || valueAsNumber > Math.pow(2, 32) - 1 ||
       !Number.isInteger(valueAsNumber)) {
     throw new Error(`Must be uint32, but got: ${value}`);
   }
 }

 /**
  * Checks whether a given object is an array of unsigned int32.
  * @param {*} values
  */
 function checkCriticalTypeUnsignedInt32Array(values) {
   // TODO(b/134765672)
   if (!CHECK_CRITICAL_TYPE) {
     return;
   }
   const array = checkCriticalTypeArray(values);
   for (const value of array) {
     checkCriticalTypeUnsignedInt32(value);
   }
 }

 /**
  * Checks whether a given object is an array of message.
  * @param {*} values
  */
 function checkCriticalTypeMessageArray(values) {
   // TODO(b/134765672)
   if (!CHECK_CRITICAL_TYPE) {
     return;
   }
   const array = checkCriticalTypeArray(values);
   for (const value of array) {
     checkCriticalType(
         value !== null, 'Given value is not a message instance: null');
   }
 }

 exports = {
   checkDefAndNotNull,
   checkCriticalElementIndex,
   checkCriticalFieldNumber,
   checkCriticalPositionIndex,
   checkCriticalRange,
   checkCriticalState,
   checkCriticalTypeBool,
   checkCriticalTypeBoolArray,
   checkCriticalTypeByteString,
   checkCriticalTypeByteStringArray,
   checkCriticalTypeDouble,
   checkTypeDouble,
   checkCriticalTypeDoubleArray,
   checkTypeFloat,
   checkCriticalTypeFloat,
   checkCriticalTypeFloatIterable,
   checkCriticalTypeMessageArray,
   checkCriticalTypeSignedInt32,
   checkCriticalTypeSignedInt32Array,
   checkCriticalTypeSignedInt64,
   checkTypeSignedInt64,
   checkCriticalTypeSignedInt64Array,
   checkCriticalTypeString,
   checkCriticalTypeStringArray,
   checkCriticalTypeUnsignedInt32,
   checkCriticalTypeUnsignedInt32Array,
   checkCriticalType,
   checkCriticalWireType,
   checkElementIndex,
   checkFieldNumber,
   checkFunctionExists,
   checkPositionIndex,
   checkRange,
   checkState,
   checkTypeUnsignedInt32,
   checkTypeSignedInt32,
   checkWireType,
   CHECK_BOUNDS,
   CHECK_CRITICAL_BOUNDS,
   CHECK_STATE,
   CHECK_CRITICAL_STATE,
   CHECK_TYPE,
   CHECK_CRITICAL_TYPE,
   MAX_FIELD_NUMBER,
   POLYFILL_TEXT_ENCODING,
 };
	/**
	* @fileoverview Proto internal runtime checks.
	*
	* Checks are grouped into different severity, see:
	* http://g3doc/third_party/protobuf/javascript/README.md#configurable-check-support-in-protocol-buffers
	*
	* Checks are also grouped into different sections:
	* - CHECK_BOUNDS:
	* Checks that ensure that indexed access is within bounds
	* (e.g. an array being accessed past its size).
	* - CHECK_STATE
	* Checks related to the state of an object
	* (e.g. a parser hitting an invalid case).
	* - CHECK_TYPE:
	* Checks that relate to type errors (e.g. code receives a number instead
	* of a string).
	*/
	goog.module('protobuf.internal.checks');

	const ByteString = goog.require('protobuf.ByteString');
	const Int64 = goog.require('protobuf.Int64');
	const WireType = goog.require('protobuf.binary.WireType');

	//
	// See
	// http://g3doc/third_party/protobuf/javascript/README.md#configurable-check-support-in-protocol-buffers
	//
	/** @define{string} */
	const CHECK_LEVEL_DEFINE = goog.define('protobuf.defines.CHECK_LEVEL', '');

	/** @define{boolean} */
	const POLYFILL_TEXT_ENCODING =
	goog.define('protobuf.defines.POLYFILL_TEXT_ENCODING', true);

	/**
	* @const {number}
	*/
	const MAX_FIELD_NUMBER = Math.pow(2, 29) - 1;

	/**
	* The largest finite float32 value.
	* @const {number}
	*/
	const FLOAT32_MAX = 3.4028234663852886e+38;

	/** @enum {number} */
	const CheckLevel = {
	DEBUG: 0,
	CRITICAL: 1,
	OFF: 2
	};


	/** @return {!CheckLevel} */
	function calculateCheckLevel() {
	const definedLevel = CHECK_LEVEL_DEFINE.toUpperCase();
	if (definedLevel === '') {
	// user did not set a value, value now just depends on goog.DEBUG
	return goog.DEBUG ? CheckLevel.DEBUG : CheckLevel.CRITICAL;
	}

	if (definedLevel === 'CRITICAL') {
	return CheckLevel.CRITICAL;
	}

	if (definedLevel === 'OFF') {
	return CheckLevel.OFF;
	}

	if (definedLevel === 'DEBUG') {
	return CheckLevel.DEBUG;
	}

	throw new Error(`Unknown value for CHECK_LEVEL: ${CHECK_LEVEL_DEFINE}`);
	}

	const /** !CheckLevel */ CHECK_LEVEL = calculateCheckLevel();

	const /** boolean */ CHECK_STATE = CHECK_LEVEL === CheckLevel.DEBUG;

	const /** boolean */ CHECK_CRITICAL_STATE =
	CHECK_LEVEL === CheckLevel.CRITICAL \|\| CHECK_LEVEL === CheckLevel.DEBUG;

	const /** boolean */ CHECK_BOUNDS = CHECK_LEVEL === CheckLevel.DEBUG;

	const /** boolean */ CHECK_CRITICAL_BOUNDS =
	CHECK_LEVEL === CheckLevel.CRITICAL \|\| CHECK_LEVEL === CheckLevel.DEBUG;

	const /** boolean */ CHECK_TYPE = CHECK_LEVEL === CheckLevel.DEBUG;

	const /** boolean */ CHECK_CRITICAL_TYPE =
	CHECK_LEVEL === CheckLevel.CRITICAL \|\| CHECK_LEVEL === CheckLevel.DEBUG;

	/**
	* Ensures the truth of an expression involving the state of the calling
	* instance, but not involving any parameters to the calling method.
	*
	* For cases where failing fast is pretty important and not failing early could
	* cause bugs that are much harder to debug.
	* @param {boolean} state
	* @param {string=} message
	* @throws {!Error} If the state is false and the check state is critical.
	*/
	function checkCriticalState(state, message = '') {
	if (!CHECK_CRITICAL_STATE) {
	return;
	}
	if (!state) {
	throw new Error(message);
	}
	}

	/**
	* Ensures the truth of an expression involving the state of the calling
	* instance, but not involving any parameters to the calling method.
	*
	* @param {boolean} state
	* @param {string=} message
	* @throws {!Error} If the state is false and the check state is debug.
	*/
	function checkState(state, message = '') {
	if (!CHECK_STATE) {
	return;
	}
	checkCriticalState(state, message);
	}

	/**
	* Ensures that `index` specifies a valid position in an indexable object of
	* size `size`. A position index may range from zero to size, inclusive.
	* @param {number} index
	* @param {number} size
	* @throws {!Error} If the index is out of range and the check state is debug.
	*/
	function checkPositionIndex(index, size) {
	if (!CHECK_BOUNDS) {
	return;
	}
	checkCriticalPositionIndex(index, size);
	}

	/**
	* Ensures that `index` specifies a valid position in an indexable object of
	* size `size`. A position index may range from zero to size, inclusive.
	* @param {number} index
	* @param {number} size
	* @throws {!Error} If the index is out of range and the check state is
	* critical.
	*/
	function checkCriticalPositionIndex(index, size) {
	if (!CHECK_CRITICAL_BOUNDS) {
	return;
	}
	if (index < 0 \|\| index > size) {
	throw new Error(`Index out of bounds: index: ${index} size: ${size}`);
	}
	}

	/**
	* Ensures that `index` specifies a valid element in an indexable object of
	* size `size`. A element index may range from zero to size, exclusive.
	* @param {number} index
	* @param {number} size
	* @throws {!Error} If the index is out of range and the check state is
	* debug.
	*/
	function checkElementIndex(index, size) {
	if (!CHECK_BOUNDS) {
	return;
	}
	checkCriticalElementIndex(index, size);
	}

	/**
	* Ensures that `index` specifies a valid element in an indexable object of
	* size `size`. A element index may range from zero to size, exclusive.
	* @param {number} index
	* @param {number} size
	* @throws {!Error} If the index is out of range and the check state is
	* critical.
	*/
	function checkCriticalElementIndex(index, size) {
	if (!CHECK_CRITICAL_BOUNDS) {
	return;
	}
	if (index < 0 \|\| index >= size) {
	throw new Error(`Index out of bounds: index: ${index} size: ${size}`);
	}
	}

	/**
	* Ensures the range of [start, end) is with the range of [0, size).
	* @param {number} start
	* @param {number} end
	* @param {number} size
	* @throws {!Error} If start and end are out of range and the check state is
	* debug.
	*/
	function checkRange(start, end, size) {
	if (!CHECK_BOUNDS) {
	return;
	}
	checkCriticalRange(start, end, size);
	}

	/**
	* Ensures the range of [start, end) is with the range of [0, size).
	* @param {number} start
	* @param {number} end
	* @param {number} size
	* @throws {!Error} If start and end are out of range and the check state is
	* critical.
	*/
	function checkCriticalRange(start, end, size) {
	if (!CHECK_CRITICAL_BOUNDS) {
	return;
	}
	if (start < 0 \|\| end < 0 \|\| start > size \|\| end > size) {
	throw new Error(`Range error: start: ${start} end: ${end} size: ${size}`);
	}
	if (start > end) {
	throw new Error(`Start > end: ${start} > ${end}`);
	}
	}

	/**
	* Ensures that field number is an integer and within the range of
	* [1, MAX_FIELD_NUMBER].
	* @param {number} fieldNumber
	* @throws {!Error} If the field number is out of range and the check state is
	* debug.
	*/
	function checkFieldNumber(fieldNumber) {
	if (!CHECK_TYPE) {
	return;
	}
	checkCriticalFieldNumber(fieldNumber);
	}

	/**
	* Ensures that the value is neither null nor undefined.
	*
	* @param {T} value
	* @return {R}
	*
	* @template T
	* @template R :=
	* mapunion(T, (V) =>
	* cond(eq(V, 'null'),
	* none(),
	* cond(eq(V, 'undefined'),
	* none(),
	* V)))
	* =:
	*/
	function checkDefAndNotNull(value) {
	if (CHECK_TYPE) {
	// Note that undefined == null.
	if (value == null) {
	throw new Error(`Value can't be null`);
	}
	}
	return value;
	}

	/**
	* Ensures that the value exists and is a function.
	*
	* @param {function(?): ?} func
	*/
	function checkFunctionExists(func) {
	if (CHECK_TYPE) {
	if (typeof func !== 'function') {
	throw new Error(`${func} is not a function`);
	}
	}
	}

	/**
	* Ensures that field number is an integer and within the range of
	* [1, MAX_FIELD_NUMBER].
	* @param {number} fieldNumber
	* @throws {!Error} If the field number is out of range and the check state is
	* critical.
	*/
	function checkCriticalFieldNumber(fieldNumber) {
	if (!CHECK_CRITICAL_TYPE) {
	return;
	}
	if (fieldNumber <= 0 \|\| fieldNumber > MAX_FIELD_NUMBER) {
	throw new Error(`Field number is out of range: ${fieldNumber}`);
	}
	}

	/**
	* Ensures that wire type is valid.
	* @param {!WireType} wireType
	* @throws {!Error} If the wire type is invalid and the check state is debug.
	*/
	function checkWireType(wireType) {
	if (!CHECK_TYPE) {
	return;
	}
	checkCriticalWireType(wireType);
	}

	/**
	* Ensures that wire type is valid.
	* @param {!WireType} wireType
	* @throws {!Error} If the wire type is invalid and the check state is critical.
	*/
	function checkCriticalWireType(wireType) {
	if (!CHECK_CRITICAL_TYPE) {
	return;
	}
	if (wireType < WireType.VARINT \|\| wireType > WireType.FIXED32) {
	throw new Error(`Invalid wire type: ${wireType}`);
	}
	}

	/**
	* Ensures the given value has the correct type.
	* @param {boolean} expression
	* @param {string} errorMsg
	* @throws {!Error} If the value has the wrong type and the check state is
	* critical.
	*/
	function checkCriticalType(expression, errorMsg) {
	if (!CHECK_CRITICAL_TYPE) {
	return;
	}
	if (!expression) {
	throw new Error(errorMsg);
	}
	}

	/**
	* Checks whether a given object is an array.
	* @param {*} value
	* @return {!Array<*>}
	*/
	function checkCriticalTypeArray(value) {
	checkCriticalType(
	Array.isArray(value), `Must be an array, but got: ${value}`);
	return /** @type {!Array<>} / (value);
	}

	/**
	* Checks whether a given object is an iterable.
	* @param {*} value
	* @return {!Iterable<*>}
	*/
	function checkCriticalTypeIterable(value) {
	checkCriticalType(
	!!value[Symbol.iterator], `Must be an iterable, but got: ${value}`);
	return /** @type {!Iterable<>} / (value);
	}

	/**
	* Checks whether a given object is a boolean.
	* @param {*} value
	*/
	function checkCriticalTypeBool(value) {
	checkCriticalType(
	typeof value === 'boolean', `Must be a boolean, but got: ${value}`);
	}

	/**
	* Checks whether a given object is an array of boolean.
	* @param {*} values
	*/
	function checkCriticalTypeBoolArray(values) {
	// TODO(b/134765672)
	if (!CHECK_CRITICAL_TYPE) {
	return;
	}
	const array = checkCriticalTypeArray(values);
	for (const value of array) {
	checkCriticalTypeBool(value);
	}
	}

	/**
	* Checks whether a given object is a ByteString.
	* @param {*} value
	*/
	function checkCriticalTypeByteString(value) {
	checkCriticalType(
	value instanceof ByteString, `Must be a ByteString, but got: ${value}`);
	}

	/**
	* Checks whether a given object is an array of ByteString.
	* @param {*} values
	*/
	function checkCriticalTypeByteStringArray(values) {
	// TODO(b/134765672)
	if (!CHECK_CRITICAL_TYPE) {
	return;
	}
	const array = checkCriticalTypeArray(values);
	for (const value of array) {
	checkCriticalTypeByteString(value);
	}
	}

	/**
	* Checks whether a given object is a number.
	* @param {*} value
	* @throws {!Error} If the value is not float and the check state is debug.
	*/
	function checkTypeDouble(value) {
	if (!CHECK_TYPE) {
	return;
	}
	checkCriticalTypeDouble(value);
	}

	/**
	* Checks whether a given object is a number.
	* @param {*} value
	* @throws {!Error} If the value is not float and the check state is critical.
	*/
	function checkCriticalTypeDouble(value) {
	checkCriticalType(
	typeof value === 'number', `Must be a number, but got: ${value}`);
	}

	/**
	* Checks whether a given object is an array of double.
	* @param {*} values
	*/
	function checkCriticalTypeDoubleArray(values) {
	// TODO(b/134765672)
	if (!CHECK_CRITICAL_TYPE) {
	return;
	}
	const array = checkCriticalTypeArray(values);
	for (const value of array) {
	checkCriticalTypeDouble(value);
	}
	}

	/**
	* Checks whether a given object is a number.
	* @param {*} value
	* @throws {!Error} If the value is not signed int32 and the check state is
	* debug.
	*/
	function checkTypeSignedInt32(value) {
	if (!CHECK_TYPE) {
	return;
	}
	checkCriticalTypeSignedInt32(value);
	}

	/**
	* Checks whether a given object is a number.
	* @param {*} value
	* @throws {!Error} If the value is not signed int32 and the check state is
	* critical.
	*/
	function checkCriticalTypeSignedInt32(value) {
	checkCriticalTypeDouble(value);
	const valueAsNumber = /** @type {number} */ (value);
	if (CHECK_CRITICAL_TYPE) {
	if (valueAsNumber < -Math.pow(2, 31) \|\| valueAsNumber > Math.pow(2, 31) \|\|
	!Number.isInteger(valueAsNumber)) {
	throw new Error(`Must be int32, but got: ${valueAsNumber}`);
	}
	}
	}

	/**
	* Checks whether a given object is an array of numbers.
	* @param {*} values
	*/
	function checkCriticalTypeSignedInt32Array(values) {
	// TODO(b/134765672)
	if (!CHECK_CRITICAL_TYPE) {
	return;
	}
	const array = checkCriticalTypeArray(values);
	for (const value of array) {
	checkCriticalTypeSignedInt32(value);
	}
	}

	/**
	* Ensures that value is a long instance.
	* @param {*} value
	* @throws {!Error} If the value is not a long instance and check state is
	* debug.
	*/
	function checkTypeSignedInt64(value) {
	if (!CHECK_TYPE) {
	return;
	}
	checkCriticalTypeSignedInt64(value);
	}

	/**
	* Ensures that value is a long instance.
	* @param {*} value
	* @throws {!Error} If the value is not a long instance and check state is
	* critical.
	*/
	function checkCriticalTypeSignedInt64(value) {
	if (!CHECK_CRITICAL_TYPE) {
	return;
	}
	if (!(value instanceof Int64)) {
	throw new Error(`Must be Int64 instance, but got: ${value}`);
	}
	}

	/**
	* Checks whether a given object is an array of long instances.
	* @param {*} values
	* @throws {!Error} If values is not an array of long instances.
	*/
	function checkCriticalTypeSignedInt64Array(values) {
	// TODO(b/134765672)
	if (!CHECK_CRITICAL_TYPE) {
	return;
	}
	const array = checkCriticalTypeArray(values);
	for (const value of array) {
	checkCriticalTypeSignedInt64(value);
	}
	}

	/**
	* Checks whether a given object is a number and within float32 precision.
	* @param {*} value
	* @throws {!Error} If the value is not float and the check state is debug.
	*/
	function checkTypeFloat(value) {
	if (!CHECK_TYPE) {
	return;
	}
	checkCriticalTypeFloat(value);
	}

	/**
	* Checks whether a given object is a number and within float32 precision.
	* @param {*} value
	* @throws {!Error} If the value is not float and the check state is critical.
	*/
	function checkCriticalTypeFloat(value) {
	checkCriticalTypeDouble(value);
	if (CHECK_CRITICAL_TYPE) {
	const valueAsNumber = /** @type {number} */ (value);
	if (Number.isFinite(valueAsNumber) &&
	(valueAsNumber > FLOAT32_MAX \|\| valueAsNumber < -FLOAT32_MAX)) {
	throw new Error(
	`Given number does not fit into float precision: ${value}`);
	}
	}
	}

	/**
	* Checks whether a given object is an iterable of floats.
	* @param {*} values
	*/
	function checkCriticalTypeFloatIterable(values) {
	// TODO(b/134765672)
	if (!CHECK_CRITICAL_TYPE) {
	return;
	}
	const iterable = checkCriticalTypeIterable(values);
	for (const value of iterable) {
	checkCriticalTypeFloat(value);
	}
	}

	/**
	* Checks whether a given object is a string.
	* @param {*} value
	*/
	function checkCriticalTypeString(value) {
	checkCriticalType(
	typeof value === 'string', `Must be string, but got: ${value}`);
	}

	/**
	* Checks whether a given object is an array of string.
	* @param {*} values
	*/
	function checkCriticalTypeStringArray(values) {
	// TODO(b/134765672)
	if (!CHECK_CRITICAL_TYPE) {
	return;
	}
	const array = checkCriticalTypeArray(values);
	for (const value of array) {
	checkCriticalTypeString(value);
	}
	}

	/**
	* Ensures that value is a valid unsigned int32.
	* @param {*} value
	* @throws {!Error} If the value is out of range and the check state is debug.
	*/
	function checkTypeUnsignedInt32(value) {
	if (!CHECK_TYPE) {
	return;
	}
	checkCriticalTypeUnsignedInt32(value);
	}

	/**
	* Ensures that value is a valid unsigned int32.
	* @param {*} value
	* @throws {!Error} If the value is out of range and the check state
	* is critical.
	*/
	function checkCriticalTypeUnsignedInt32(value) {
	if (!CHECK_CRITICAL_TYPE) {
	return;
	}
	checkCriticalTypeDouble(value);
	const valueAsNumber = /** @type {number} */ (value);
	if (valueAsNumber < 0 \|\| valueAsNumber > Math.pow(2, 32) - 1 \|\|
	!Number.isInteger(valueAsNumber)) {
	throw new Error(`Must be uint32, but got: ${value}`);
	}
	}

	/**
	* Checks whether a given object is an array of unsigned int32.
	* @param {*} values
	*/
	function checkCriticalTypeUnsignedInt32Array(values) {
	// TODO(b/134765672)
	if (!CHECK_CRITICAL_TYPE) {
	return;
	}
	const array = checkCriticalTypeArray(values);
	for (const value of array) {
	checkCriticalTypeUnsignedInt32(value);
	}
	}

	/**
	* Checks whether a given object is an array of message.
	* @param {*} values
	*/
	function checkCriticalTypeMessageArray(values) {
	// TODO(b/134765672)
	if (!CHECK_CRITICAL_TYPE) {
	return;
	}
	const array = checkCriticalTypeArray(values);
	for (const value of array) {
	checkCriticalType(
	value !== null, 'Given value is not a message instance: null');
	}
	}

	exports = {
	checkDefAndNotNull,
	checkCriticalElementIndex,
	checkCriticalFieldNumber,
	checkCriticalPositionIndex,
	checkCriticalRange,
	checkCriticalState,
	checkCriticalTypeBool,
	checkCriticalTypeBoolArray,
	checkCriticalTypeByteString,
	checkCriticalTypeByteStringArray,
	checkCriticalTypeDouble,
	checkTypeDouble,
	checkCriticalTypeDoubleArray,
	checkTypeFloat,
	checkCriticalTypeFloat,
	checkCriticalTypeFloatIterable,
	checkCriticalTypeMessageArray,
	checkCriticalTypeSignedInt32,
	checkCriticalTypeSignedInt32Array,
	checkCriticalTypeSignedInt64,
	checkTypeSignedInt64,
	checkCriticalTypeSignedInt64Array,
	checkCriticalTypeString,
	checkCriticalTypeStringArray,
	checkCriticalTypeUnsignedInt32,
	checkCriticalTypeUnsignedInt32Array,
	checkCriticalType,
	checkCriticalWireType,
	checkElementIndex,
	checkFieldNumber,
	checkFunctionExists,
	checkPositionIndex,
	checkRange,
	checkState,
	checkTypeUnsignedInt32,
	checkTypeSignedInt32,
	checkWireType,
	CHECK_BOUNDS,
	CHECK_CRITICAL_BOUNDS,
	CHECK_STATE,
	CHECK_CRITICAL_STATE,
	CHECK_TYPE,
	CHECK_CRITICAL_TYPE,
	MAX_FIELD_NUMBER,
	POLYFILL_TEXT_ENCODING,
	};