1 | const typedArrayTypeNames = [
|
2 | 'Int8Array',
|
3 | 'Uint8Array',
|
4 | 'Uint8ClampedArray',
|
5 | 'Int16Array',
|
6 | 'Uint16Array',
|
7 | 'Int32Array',
|
8 | 'Uint32Array',
|
9 | 'Float32Array',
|
10 | 'Float64Array',
|
11 | 'BigInt64Array',
|
12 | 'BigUint64Array',
|
13 | ];
|
14 | function isTypedArrayName(name) {
|
15 | return typedArrayTypeNames.includes(name);
|
16 | }
|
17 | const objectTypeNames = [
|
18 | 'Function',
|
19 | 'Generator',
|
20 | 'AsyncGenerator',
|
21 | 'GeneratorFunction',
|
22 | 'AsyncGeneratorFunction',
|
23 | 'AsyncFunction',
|
24 | 'Observable',
|
25 | 'Array',
|
26 | 'Buffer',
|
27 | 'Blob',
|
28 | 'Object',
|
29 | 'RegExp',
|
30 | 'Date',
|
31 | 'Error',
|
32 | 'Map',
|
33 | 'Set',
|
34 | 'WeakMap',
|
35 | 'WeakSet',
|
36 | 'WeakRef',
|
37 | 'ArrayBuffer',
|
38 | 'SharedArrayBuffer',
|
39 | 'DataView',
|
40 | 'Promise',
|
41 | 'URL',
|
42 | 'FormData',
|
43 | 'URLSearchParams',
|
44 | 'HTMLElement',
|
45 | 'NaN',
|
46 | ...typedArrayTypeNames,
|
47 | ];
|
48 | function isObjectTypeName(name) {
|
49 | return objectTypeNames.includes(name);
|
50 | }
|
51 | const primitiveTypeNames = [
|
52 | 'null',
|
53 | 'undefined',
|
54 | 'string',
|
55 | 'number',
|
56 | 'bigint',
|
57 | 'boolean',
|
58 | 'symbol',
|
59 | ];
|
60 | function isPrimitiveTypeName(name) {
|
61 | return primitiveTypeNames.includes(name);
|
62 | }
|
63 |
|
64 | function isOfType(type) {
|
65 | return (value) => typeof value === type;
|
66 | }
|
67 | const { toString } = Object.prototype;
|
68 | const getObjectType = (value) => {
|
69 | const objectTypeName = toString.call(value).slice(8, -1);
|
70 | if (/HTML\w+Element/.test(objectTypeName) && is.domElement(value)) {
|
71 | return 'HTMLElement';
|
72 | }
|
73 | if (isObjectTypeName(objectTypeName)) {
|
74 | return objectTypeName;
|
75 | }
|
76 | return undefined;
|
77 | };
|
78 | const isObjectOfType = (type) => (value) => getObjectType(value) === type;
|
79 | function is(value) {
|
80 | if (value === null) {
|
81 | return 'null';
|
82 | }
|
83 | switch (typeof value) {
|
84 | case 'undefined': {
|
85 | return 'undefined';
|
86 | }
|
87 | case 'string': {
|
88 | return 'string';
|
89 | }
|
90 | case 'number': {
|
91 | return Number.isNaN(value) ? 'NaN' : 'number';
|
92 | }
|
93 | case 'boolean': {
|
94 | return 'boolean';
|
95 | }
|
96 | case 'function': {
|
97 | return 'Function';
|
98 | }
|
99 | case 'bigint': {
|
100 | return 'bigint';
|
101 | }
|
102 | case 'symbol': {
|
103 | return 'symbol';
|
104 | }
|
105 | default:
|
106 | }
|
107 | if (is.observable(value)) {
|
108 | return 'Observable';
|
109 | }
|
110 | if (is.array(value)) {
|
111 | return 'Array';
|
112 | }
|
113 | if (is.buffer(value)) {
|
114 | return 'Buffer';
|
115 | }
|
116 | const tagType = getObjectType(value);
|
117 | if (tagType) {
|
118 | return tagType;
|
119 | }
|
120 | if (value instanceof String || value instanceof Boolean || value instanceof Number) {
|
121 | throw new TypeError('Please don\'t use object wrappers for primitive types');
|
122 | }
|
123 | return 'Object';
|
124 | }
|
125 | is.undefined = isOfType('undefined');
|
126 | is.string = isOfType('string');
|
127 | const isNumberType = isOfType('number');
|
128 | is.number = (value) => isNumberType(value) && !is.nan(value);
|
129 | is.bigint = isOfType('bigint');
|
130 |
|
131 | is.function_ = isOfType('function');
|
132 |
|
133 | is.null_ = (value) => value === null;
|
134 | is.class_ = (value) => is.function_(value) && value.toString().startsWith('class ');
|
135 | is.boolean = (value) => value === true || value === false;
|
136 | is.symbol = isOfType('symbol');
|
137 | is.numericString = (value) => is.string(value) && !is.emptyStringOrWhitespace(value) && !Number.isNaN(Number(value));
|
138 | is.array = (value, assertion) => {
|
139 | if (!Array.isArray(value)) {
|
140 | return false;
|
141 | }
|
142 | if (!is.function_(assertion)) {
|
143 | return true;
|
144 | }
|
145 |
|
146 | return value.every(element => assertion(element));
|
147 | };
|
148 |
|
149 | is.buffer = (value) => value?.constructor?.isBuffer?.(value) ?? false;
|
150 | is.blob = (value) => isObjectOfType('Blob')(value);
|
151 | is.nullOrUndefined = (value) => is.null_(value) || is.undefined(value);
|
152 | is.object = (value) => !is.null_(value) && (typeof value === 'object' || is.function_(value));
|
153 | is.iterable = (value) => is.function_(value?.[Symbol.iterator]);
|
154 | is.asyncIterable = (value) => is.function_(value?.[Symbol.asyncIterator]);
|
155 | is.generator = (value) => is.iterable(value) && is.function_(value?.next) && is.function_(value?.throw);
|
156 | is.asyncGenerator = (value) => is.asyncIterable(value) && is.function_(value.next) && is.function_(value.throw);
|
157 | is.nativePromise = (value) => isObjectOfType('Promise')(value);
|
158 | const hasPromiseApi = (value) => is.function_(value?.then)
|
159 | && is.function_(value?.catch);
|
160 | is.promise = (value) => is.nativePromise(value) || hasPromiseApi(value);
|
161 | is.generatorFunction = isObjectOfType('GeneratorFunction');
|
162 | is.asyncGeneratorFunction = (value) => getObjectType(value) === 'AsyncGeneratorFunction';
|
163 | is.asyncFunction = (value) => getObjectType(value) === 'AsyncFunction';
|
164 |
|
165 | is.boundFunction = (value) => is.function_(value) && !value.hasOwnProperty('prototype');
|
166 | is.regExp = isObjectOfType('RegExp');
|
167 | is.date = isObjectOfType('Date');
|
168 | is.error = isObjectOfType('Error');
|
169 | is.map = (value) => isObjectOfType('Map')(value);
|
170 | is.set = (value) => isObjectOfType('Set')(value);
|
171 | is.weakMap = (value) => isObjectOfType('WeakMap')(value);
|
172 | is.weakSet = (value) => isObjectOfType('WeakSet')(value);
|
173 | is.weakRef = (value) => isObjectOfType('WeakRef')(value);
|
174 | is.int8Array = isObjectOfType('Int8Array');
|
175 | is.uint8Array = isObjectOfType('Uint8Array');
|
176 | is.uint8ClampedArray = isObjectOfType('Uint8ClampedArray');
|
177 | is.int16Array = isObjectOfType('Int16Array');
|
178 | is.uint16Array = isObjectOfType('Uint16Array');
|
179 | is.int32Array = isObjectOfType('Int32Array');
|
180 | is.uint32Array = isObjectOfType('Uint32Array');
|
181 | is.float32Array = isObjectOfType('Float32Array');
|
182 | is.float64Array = isObjectOfType('Float64Array');
|
183 | is.bigInt64Array = isObjectOfType('BigInt64Array');
|
184 | is.bigUint64Array = isObjectOfType('BigUint64Array');
|
185 | is.arrayBuffer = isObjectOfType('ArrayBuffer');
|
186 | is.sharedArrayBuffer = isObjectOfType('SharedArrayBuffer');
|
187 | is.dataView = isObjectOfType('DataView');
|
188 |
|
189 | is.enumCase = (value, targetEnum) => Object.values(targetEnum).includes(value);
|
190 | is.directInstanceOf = (instance, class_) => Object.getPrototypeOf(instance) === class_.prototype;
|
191 | is.urlInstance = (value) => isObjectOfType('URL')(value);
|
192 | is.urlString = (value) => {
|
193 | if (!is.string(value)) {
|
194 | return false;
|
195 | }
|
196 | try {
|
197 | new URL(value);
|
198 | return true;
|
199 | }
|
200 | catch {
|
201 | return false;
|
202 | }
|
203 | };
|
204 |
|
205 | is.truthy = (value) => Boolean(value);
|
206 |
|
207 | is.falsy = (value) => !value;
|
208 | is.nan = (value) => Number.isNaN(value);
|
209 | is.primitive = (value) => is.null_(value) || isPrimitiveTypeName(typeof value);
|
210 | is.integer = (value) => Number.isInteger(value);
|
211 | is.safeInteger = (value) => Number.isSafeInteger(value);
|
212 | is.plainObject = (value) => {
|
213 |
|
214 | if (typeof value !== 'object' || value === null) {
|
215 | return false;
|
216 | }
|
217 |
|
218 | const prototype = Object.getPrototypeOf(value);
|
219 | return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
|
220 | };
|
221 | is.typedArray = (value) => isTypedArrayName(getObjectType(value));
|
222 | const isValidLength = (value) => is.safeInteger(value) && value >= 0;
|
223 | is.arrayLike = (value) => !is.nullOrUndefined(value) && !is.function_(value) && isValidLength(value.length);
|
224 | is.inRange = (value, range) => {
|
225 | if (is.number(range)) {
|
226 | return value >= Math.min(0, range) && value <= Math.max(range, 0);
|
227 | }
|
228 | if (is.array(range) && range.length === 2) {
|
229 | return value >= Math.min(...range) && value <= Math.max(...range);
|
230 | }
|
231 | throw new TypeError(`Invalid range: ${JSON.stringify(range)}`);
|
232 | };
|
233 |
|
234 | const NODE_TYPE_ELEMENT = 1;
|
235 |
|
236 | const DOM_PROPERTIES_TO_CHECK = [
|
237 | 'innerHTML',
|
238 | 'ownerDocument',
|
239 | 'style',
|
240 | 'attributes',
|
241 | 'nodeValue',
|
242 | ];
|
243 | is.domElement = (value) => is.object(value)
|
244 | && value.nodeType === NODE_TYPE_ELEMENT
|
245 | && is.string(value.nodeName)
|
246 | && !is.plainObject(value)
|
247 | && DOM_PROPERTIES_TO_CHECK.every(property => property in value);
|
248 | is.observable = (value) => {
|
249 | if (!value) {
|
250 | return false;
|
251 | }
|
252 |
|
253 | if (value === value[Symbol.observable]?.()) {
|
254 | return true;
|
255 | }
|
256 |
|
257 | if (value === value['@@observable']?.()) {
|
258 | return true;
|
259 | }
|
260 | return false;
|
261 | };
|
262 | is.nodeStream = (value) => is.object(value) && is.function_(value.pipe) && !is.observable(value);
|
263 | is.infinite = (value) => value === Number.POSITIVE_INFINITY || value === Number.NEGATIVE_INFINITY;
|
264 | const isAbsoluteMod2 = (remainder) => (value) => is.integer(value) && Math.abs(value % 2) === remainder;
|
265 | is.evenInteger = isAbsoluteMod2(0);
|
266 | is.oddInteger = isAbsoluteMod2(1);
|
267 | is.emptyArray = (value) => is.array(value) && value.length === 0;
|
268 | is.nonEmptyArray = (value) => is.array(value) && value.length > 0;
|
269 | is.emptyString = (value) => is.string(value) && value.length === 0;
|
270 | const isWhiteSpaceString = (value) => is.string(value) && !/\S/.test(value);
|
271 | is.emptyStringOrWhitespace = (value) => is.emptyString(value) || isWhiteSpaceString(value);
|
272 |
|
273 | is.nonEmptyString = (value) => is.string(value) && value.length > 0;
|
274 |
|
275 | is.nonEmptyStringAndNotWhitespace = (value) => is.string(value) && !is.emptyStringOrWhitespace(value);
|
276 |
|
277 | is.emptyObject = (value) => is.object(value) && !is.map(value) && !is.set(value) && Object.keys(value).length === 0;
|
278 |
|
279 |
|
280 |
|
281 | is.nonEmptyObject = (value) => is.object(value) && !is.map(value) && !is.set(value) && Object.keys(value).length > 0;
|
282 | is.emptySet = (value) => is.set(value) && value.size === 0;
|
283 | is.nonEmptySet = (value) => is.set(value) && value.size > 0;
|
284 |
|
285 | is.emptyMap = (value) => is.map(value) && value.size === 0;
|
286 |
|
287 | is.nonEmptyMap = (value) => is.map(value) && value.size > 0;
|
288 |
|
289 | is.propertyKey = (value) => is.any([is.string, is.number, is.symbol], value);
|
290 | is.formData = (value) => isObjectOfType('FormData')(value);
|
291 | is.urlSearchParams = (value) => isObjectOfType('URLSearchParams')(value);
|
292 | const predicateOnArray = (method, predicate, values) => {
|
293 | if (!is.function_(predicate)) {
|
294 | throw new TypeError(`Invalid predicate: ${JSON.stringify(predicate)}`);
|
295 | }
|
296 | if (values.length === 0) {
|
297 | throw new TypeError('Invalid number of values');
|
298 | }
|
299 | return method.call(values, predicate);
|
300 | };
|
301 | is.any = (predicate, ...values) => {
|
302 | const predicates = is.array(predicate) ? predicate : [predicate];
|
303 | return predicates.some(singlePredicate => predicateOnArray(Array.prototype.some, singlePredicate, values));
|
304 | };
|
305 | is.all = (predicate, ...values) => predicateOnArray(Array.prototype.every, predicate, values);
|
306 | const assertType = (condition, description, value, options = {}) => {
|
307 | if (!condition) {
|
308 | const { multipleValues } = options;
|
309 | const valuesMessage = multipleValues
|
310 | ? `received values of types ${[
|
311 | ...new Set(value.map(singleValue => `\`${is(singleValue)}\``)),
|
312 | ].join(', ')}`
|
313 | : `received value of type \`${is(value)}\``;
|
314 | throw new TypeError(`Expected value which is \`${description}\`, ${valuesMessage}.`);
|
315 | }
|
316 | };
|
317 |
|
318 | export const assert = {
|
319 |
|
320 | undefined: (value) => assertType(is.undefined(value), 'undefined', value),
|
321 | string: (value) => assertType(is.string(value), 'string', value),
|
322 | number: (value) => assertType(is.number(value), 'number', value),
|
323 | bigint: (value) => assertType(is.bigint(value), 'bigint', value),
|
324 |
|
325 | function_: (value) => assertType(is.function_(value), 'Function', value),
|
326 | null_: (value) => assertType(is.null_(value), 'null', value),
|
327 | class_: (value) => assertType(is.class_(value), "Class" , value),
|
328 | boolean: (value) => assertType(is.boolean(value), 'boolean', value),
|
329 | symbol: (value) => assertType(is.symbol(value), 'symbol', value),
|
330 | numericString: (value) => assertType(is.numericString(value), "string with a number" , value),
|
331 | array: (value, assertion) => {
|
332 | const assert = assertType;
|
333 | assert(is.array(value), 'Array', value);
|
334 | if (assertion) {
|
335 |
|
336 | value.forEach(assertion);
|
337 | }
|
338 | },
|
339 | buffer: (value) => assertType(is.buffer(value), 'Buffer', value),
|
340 | blob: (value) => assertType(is.blob(value), 'Blob', value),
|
341 | nullOrUndefined: (value) => assertType(is.nullOrUndefined(value), "null or undefined" , value),
|
342 | object: (value) => assertType(is.object(value), 'Object', value),
|
343 | iterable: (value) => assertType(is.iterable(value), "Iterable" , value),
|
344 | asyncIterable: (value) => assertType(is.asyncIterable(value), "AsyncIterable" , value),
|
345 | generator: (value) => assertType(is.generator(value), 'Generator', value),
|
346 | asyncGenerator: (value) => assertType(is.asyncGenerator(value), 'AsyncGenerator', value),
|
347 | nativePromise: (value) => assertType(is.nativePromise(value), "native Promise" , value),
|
348 | promise: (value) => assertType(is.promise(value), 'Promise', value),
|
349 | generatorFunction: (value) => assertType(is.generatorFunction(value), 'GeneratorFunction', value),
|
350 | asyncGeneratorFunction: (value) => assertType(is.asyncGeneratorFunction(value), 'AsyncGeneratorFunction', value),
|
351 |
|
352 | asyncFunction: (value) => assertType(is.asyncFunction(value), 'AsyncFunction', value),
|
353 |
|
354 | boundFunction: (value) => assertType(is.boundFunction(value), 'Function', value),
|
355 | regExp: (value) => assertType(is.regExp(value), 'RegExp', value),
|
356 | date: (value) => assertType(is.date(value), 'Date', value),
|
357 | error: (value) => assertType(is.error(value), 'Error', value),
|
358 | map: (value) => assertType(is.map(value), 'Map', value),
|
359 | set: (value) => assertType(is.set(value), 'Set', value),
|
360 | weakMap: (value) => assertType(is.weakMap(value), 'WeakMap', value),
|
361 | weakSet: (value) => assertType(is.weakSet(value), 'WeakSet', value),
|
362 | weakRef: (value) => assertType(is.weakRef(value), 'WeakRef', value),
|
363 | int8Array: (value) => assertType(is.int8Array(value), 'Int8Array', value),
|
364 | uint8Array: (value) => assertType(is.uint8Array(value), 'Uint8Array', value),
|
365 | uint8ClampedArray: (value) => assertType(is.uint8ClampedArray(value), 'Uint8ClampedArray', value),
|
366 | int16Array: (value) => assertType(is.int16Array(value), 'Int16Array', value),
|
367 | uint16Array: (value) => assertType(is.uint16Array(value), 'Uint16Array', value),
|
368 | int32Array: (value) => assertType(is.int32Array(value), 'Int32Array', value),
|
369 | uint32Array: (value) => assertType(is.uint32Array(value), 'Uint32Array', value),
|
370 | float32Array: (value) => assertType(is.float32Array(value), 'Float32Array', value),
|
371 | float64Array: (value) => assertType(is.float64Array(value), 'Float64Array', value),
|
372 | bigInt64Array: (value) => assertType(is.bigInt64Array(value), 'BigInt64Array', value),
|
373 | bigUint64Array: (value) => assertType(is.bigUint64Array(value), 'BigUint64Array', value),
|
374 | arrayBuffer: (value) => assertType(is.arrayBuffer(value), 'ArrayBuffer', value),
|
375 | sharedArrayBuffer: (value) => assertType(is.sharedArrayBuffer(value), 'SharedArrayBuffer', value),
|
376 | dataView: (value) => assertType(is.dataView(value), 'DataView', value),
|
377 | enumCase: (value, targetEnum) => assertType(is.enumCase(value, targetEnum), 'EnumCase', value),
|
378 | urlInstance: (value) => assertType(is.urlInstance(value), 'URL', value),
|
379 | urlString: (value) => assertType(is.urlString(value), "string with a URL" /* AssertionTypeDescription.urlString */, value),
|
380 | truthy: (value) => assertType(is.truthy(value), "truthy" /* AssertionTypeDescription.truthy */, value),
|
381 | falsy: (value) => assertType(is.falsy(value), "falsy" /* AssertionTypeDescription.falsy */, value),
|
382 | nan: (value) => assertType(is.nan(value), "NaN" /* AssertionTypeDescription.nan */, value),
|
383 | primitive: (value) => assertType(is.primitive(value), "primitive" /* AssertionTypeDescription.primitive */, value),
|
384 | integer: (value) => assertType(is.integer(value), "integer" /* AssertionTypeDescription.integer */, value),
|
385 | safeInteger: (value) => assertType(is.safeInteger(value), "integer" /* AssertionTypeDescription.safeInteger */, value),
|
386 | plainObject: (value) => assertType(is.plainObject(value), "plain object" /* AssertionTypeDescription.plainObject */, value),
|
387 | typedArray: (value) => assertType(is.typedArray(value), "TypedArray" /* AssertionTypeDescription.typedArray */, value),
|
388 | arrayLike: (value) => assertType(is.arrayLike(value), "array-like" /* AssertionTypeDescription.arrayLike */, value),
|
389 | domElement: (value) => assertType(is.domElement(value), "HTMLElement" /* AssertionTypeDescription.domElement */, value),
|
390 | observable: (value) => assertType(is.observable(value), 'Observable', value),
|
391 | nodeStream: (value) => assertType(is.nodeStream(value), "Node.js Stream" /* AssertionTypeDescription.nodeStream */, value),
|
392 | infinite: (value) => assertType(is.infinite(value), "infinite number" /* AssertionTypeDescription.infinite */, value),
|
393 | emptyArray: (value) => assertType(is.emptyArray(value), "empty array" /* AssertionTypeDescription.emptyArray */, value),
|
394 | nonEmptyArray: (value) => assertType(is.nonEmptyArray(value), "non-empty array" /* AssertionTypeDescription.nonEmptyArray */, value),
|
395 | emptyString: (value) => assertType(is.emptyString(value), "empty string" /* AssertionTypeDescription.emptyString */, value),
|
396 | emptyStringOrWhitespace: (value) => assertType(is.emptyStringOrWhitespace(value), "empty string or whitespace" /* AssertionTypeDescription.emptyStringOrWhitespace */, value),
|
397 | nonEmptyString: (value) => assertType(is.nonEmptyString(value), "non-empty string" /* AssertionTypeDescription.nonEmptyString */, value),
|
398 | nonEmptyStringAndNotWhitespace: (value) => assertType(is.nonEmptyStringAndNotWhitespace(value), "non-empty string and not whitespace" /* AssertionTypeDescription.nonEmptyStringAndNotWhitespace */, value),
|
399 | emptyObject: (value) => assertType(is.emptyObject(value), "empty object" /* AssertionTypeDescription.emptyObject */, value),
|
400 | nonEmptyObject: (value) => assertType(is.nonEmptyObject(value), "non-empty object" /* AssertionTypeDescription.nonEmptyObject */, value),
|
401 | emptySet: (value) => assertType(is.emptySet(value), "empty set" /* AssertionTypeDescription.emptySet */, value),
|
402 | nonEmptySet: (value) => assertType(is.nonEmptySet(value), "non-empty set" /* AssertionTypeDescription.nonEmptySet */, value),
|
403 | emptyMap: (value) => assertType(is.emptyMap(value), "empty map" /* AssertionTypeDescription.emptyMap */, value),
|
404 | nonEmptyMap: (value) => assertType(is.nonEmptyMap(value), "non-empty map" /* AssertionTypeDescription.nonEmptyMap */, value),
|
405 | propertyKey: (value) => assertType(is.propertyKey(value), 'PropertyKey', value),
|
406 | formData: (value) => assertType(is.formData(value), 'FormData', value),
|
407 | urlSearchParams: (value) => assertType(is.urlSearchParams(value), 'URLSearchParams', value),
|
408 | // Numbers.
|
409 | evenInteger: (value) => assertType(is.evenInteger(value), "even integer" /* AssertionTypeDescription.evenInteger */, value),
|
410 | oddInteger: (value) => assertType(is.oddInteger(value), "odd integer" /* AssertionTypeDescription.oddInteger */, value),
|
411 | // Two arguments.
|
412 | directInstanceOf: (instance, class_) => assertType(is.directInstanceOf(instance, class_), "T" /* AssertionTypeDescription.directInstanceOf */, instance),
|
413 | inRange: (value, range) => assertType(is.inRange(value, range), "in range" /* AssertionTypeDescription.inRange */, value),
|
414 | // Variadic functions.
|
415 | any: (predicate, ...values) => assertType(is.any(predicate, ...values), "predicate returns truthy for any value" /* AssertionTypeDescription.any */, values, { multipleValues: true }),
|
416 | all: (predicate, ...values) => assertType(is.all(predicate, ...values), "predicate returns truthy for all values" , values, { multipleValues: true }),
|
417 | };
|
418 |
|
419 |
|
420 |
|
421 | Object.defineProperties(is, {
|
422 | class: {
|
423 | value: is.class_,
|
424 | },
|
425 | function: {
|
426 | value: is.function_,
|
427 | },
|
428 | null: {
|
429 | value: is.null_,
|
430 | },
|
431 | });
|
432 | Object.defineProperties(assert, {
|
433 | class: {
|
434 | value: assert.class_,
|
435 | },
|
436 | function: {
|
437 | value: assert.function_,
|
438 | },
|
439 | null: {
|
440 | value: assert.null_,
|
441 | },
|
442 | });
|
443 | export default is;
|