index.js (41485B)
1 /** 2 * @license Apache-2.0 3 * 4 * Copyright (c) 2018 The Stdlib Authors. 5 * 6 * Licensed under the Apache License, Version 2.0 (the "License"); 7 * you may not use this file except in compliance with the License. 8 * You may obtain a copy of the License at 9 * 10 * http://www.apache.org/licenses/LICENSE-2.0 11 * 12 * Unless required by applicable law or agreed to in writing, software 13 * distributed under the License is distributed on an "AS IS" BASIS, 14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 * See the License for the specific language governing permissions and 16 * limitations under the License. 17 */ 18 19 'use strict'; 20 21 /* 22 * When adding modules to the namespace, ensure that they are added in alphabetical order according to module name. 23 */ 24 25 /* 26 * The following modules are intentionally not exported: library-manifest 27 */ 28 29 // MODULES // 30 31 var setReadOnly = require( './../define-read-only-property' ); 32 33 34 // MAIN // 35 36 /** 37 * Top-level namespace. 38 * 39 * @namespace utils 40 */ 41 var utils = {}; 42 43 /** 44 * @name any 45 * @memberof utils 46 * @readonly 47 * @type {Function} 48 * @see {@link module:@stdlib/utils/any} 49 */ 50 setReadOnly( utils, 'any', require( './../any' ) ); 51 52 /** 53 * @name anyBy 54 * @memberof utils 55 * @readonly 56 * @type {Function} 57 * @see {@link module:@stdlib/utils/any-by} 58 */ 59 setReadOnly( utils, 'anyBy', require( './../any-by' ) ); 60 61 /** 62 * @name anyByRight 63 * @memberof utils 64 * @readonly 65 * @type {Function} 66 * @see {@link module:@stdlib/utils/any-by-right} 67 */ 68 setReadOnly( utils, 'anyByRight', require( './../any-by-right' ) ); 69 70 /** 71 * @name append 72 * @memberof utils 73 * @readonly 74 * @type {Function} 75 * @see {@link module:@stdlib/utils/append} 76 */ 77 setReadOnly( utils, 'append', require( './../append' ) ); 78 79 /** 80 * @name argumentFunction 81 * @memberof utils 82 * @readonly 83 * @type {Function} 84 * @see {@link module:@stdlib/utils/argument-function} 85 */ 86 setReadOnly( utils, 'argumentFunction', require( './../argument-function' ) ); 87 88 /** 89 * @name async 90 * @memberof utils 91 * @readonly 92 * @type {Namespace} 93 * @see {@link module:@stdlib/utils/async} 94 */ 95 setReadOnly( utils, 'async', require( './../async' ) ); 96 97 /** 98 * @name bifurcate 99 * @memberof utils 100 * @readonly 101 * @type {Function} 102 * @see {@link module:@stdlib/utils/bifurcate} 103 */ 104 setReadOnly( utils, 'bifurcate', require( './../bifurcate' ) ); 105 106 /** 107 * @name bifurcateBy 108 * @memberof utils 109 * @readonly 110 * @type {Function} 111 * @see {@link module:@stdlib/utils/bifurcate-by} 112 */ 113 setReadOnly( utils, 'bifurcateBy', require( './../bifurcate-by' ) ); 114 115 /** 116 * @name bifurcateIn 117 * @memberof utils 118 * @readonly 119 * @type {Function} 120 * @see {@link module:@stdlib/utils/bifurcate-in} 121 */ 122 setReadOnly( utils, 'bifurcateIn', require( './../bifurcate-in' ) ); 123 124 /** 125 * @name bifurcateOwn 126 * @memberof utils 127 * @readonly 128 * @type {Function} 129 * @see {@link module:@stdlib/utils/bifurcate-own} 130 */ 131 setReadOnly( utils, 'bifurcateOwn', require( './../bifurcate-own' ) ); 132 133 /** 134 * @name capitalizeKeys 135 * @memberof utils 136 * @readonly 137 * @type {Function} 138 * @see {@link module:@stdlib/utils/capitalize-keys} 139 */ 140 setReadOnly( utils, 'capitalizeKeys', require( './../capitalize-keys' ) ); 141 142 /** 143 * @name CircularBuffer 144 * @memberof utils 145 * @readonly 146 * @type {Function} 147 * @see {@link module:@stdlib/utils/circular-buffer} 148 */ 149 setReadOnly( utils, 'CircularBuffer', require( './../circular-buffer' ) ); 150 151 /** 152 * @name CompactAdjacencyMatrix 153 * @memberof utils 154 * @readonly 155 * @type {Function} 156 * @see {@link module:@stdlib/utils/compact-adjacency-matrix} 157 */ 158 setReadOnly( utils, 'CompactAdjacencyMatrix', require( './../compact-adjacency-matrix' ) ); 159 160 /** 161 * @name compose 162 * @memberof utils 163 * @readonly 164 * @type {Function} 165 * @see {@link module:@stdlib/utils/compose} 166 */ 167 setReadOnly( utils, 'compose', require( './../compose' ) ); 168 169 /** 170 * @name constantFunction 171 * @memberof utils 172 * @readonly 173 * @type {Function} 174 * @see {@link module:@stdlib/utils/constant-function} 175 */ 176 setReadOnly( utils, 'constantFunction', require( './../constant-function' ) ); 177 178 /** 179 * @name constructorName 180 * @memberof utils 181 * @readonly 182 * @type {Function} 183 * @see {@link module:@stdlib/utils/constructor-name} 184 */ 185 setReadOnly( utils, 'constructorName', require( './../constructor-name' ) ); 186 187 /** 188 * @name convertPath 189 * @memberof utils 190 * @readonly 191 * @type {Function} 192 * @see {@link module:@stdlib/utils/convert-path} 193 */ 194 setReadOnly( utils, 'convertPath', require( './../convert-path' ) ); 195 196 /** 197 * @name copy 198 * @memberof utils 199 * @readonly 200 * @type {Function} 201 * @see {@link module:@stdlib/utils/copy} 202 */ 203 setReadOnly( utils, 'copy', require( './../copy' ) ); 204 205 /** 206 * @name countBy 207 * @memberof utils 208 * @readonly 209 * @type {Function} 210 * @see {@link module:@stdlib/utils/count-by} 211 */ 212 setReadOnly( utils, 'countBy', require( './../count-by' ) ); 213 214 /** 215 * @name curry 216 * @memberof utils 217 * @readonly 218 * @type {Function} 219 * @see {@link module:@stdlib/utils/curry} 220 */ 221 setReadOnly( utils, 'curry', require( './../curry' ) ); 222 223 /** 224 * @name curryRight 225 * @memberof utils 226 * @readonly 227 * @type {Function} 228 * @see {@link module:@stdlib/utils/curry-right} 229 */ 230 setReadOnly( utils, 'curryRight', require( './../curry-right' ) ); 231 232 /** 233 * @name deepGet 234 * @memberof utils 235 * @readonly 236 * @type {Function} 237 * @see {@link module:@stdlib/utils/deep-get} 238 */ 239 setReadOnly( utils, 'deepGet', require( './../deep-get' ) ); 240 241 /** 242 * @name deepPluck 243 * @memberof utils 244 * @readonly 245 * @type {Function} 246 * @see {@link module:@stdlib/utils/deep-pluck} 247 */ 248 setReadOnly( utils, 'deepPluck', require( './../deep-pluck' ) ); 249 250 /** 251 * @name deepSet 252 * @memberof utils 253 * @readonly 254 * @type {Function} 255 * @see {@link module:@stdlib/utils/deep-set} 256 */ 257 setReadOnly( utils, 'deepSet', require( './../deep-set' ) ); 258 259 /** 260 * @name setConfigurableReadOnlyAccessor 261 * @memberof utils 262 * @readonly 263 * @type {Function} 264 * @see {@link module:@stdlib/utils/define-configurable-read-only-accessor} 265 */ 266 setReadOnly( utils, 'setConfigurableReadOnlyAccessor', require( './../define-configurable-read-only-accessor' ) ); 267 268 /** 269 * @name setConfigurableReadOnly 270 * @memberof utils 271 * @readonly 272 * @type {Function} 273 * @see {@link module:@stdlib/utils/define-configurable-read-only-property} 274 */ 275 setReadOnly( utils, 'setConfigurableReadOnly', require( './../define-configurable-read-only-property' ) ); 276 277 /** 278 * @name setConfigurableReadWriteAccessor 279 * @memberof utils 280 * @readonly 281 * @type {Function} 282 * @see {@link module:@stdlib/utils/define-configurable-read-write-accessor} 283 */ 284 setReadOnly( utils, 'setConfigurableReadWriteAccessor', require( './../define-configurable-read-write-accessor' ) ); 285 286 /** 287 * @name setConfigurableWriteOnlyAccessor 288 * @memberof utils 289 * @readonly 290 * @type {Function} 291 * @see {@link module:@stdlib/utils/define-configurable-write-only-accessor} 292 */ 293 setReadOnly( utils, 'setConfigurableWriteOnlyAccessor', require( './../define-configurable-write-only-accessor' ) ); 294 295 /** 296 * @name setMemoizedConfigurableReadOnly 297 * @memberof utils 298 * @readonly 299 * @type {Function} 300 * @see {@link module:@stdlib/utils/define-memoized-configurable-read-only-property} 301 */ 302 setReadOnly( utils, 'setMemoizedConfigurableReadOnly', require( './../define-memoized-configurable-read-only-property' ) ); 303 304 /** 305 * @name defineMemoizedProperty 306 * @memberof utils 307 * @readonly 308 * @type {Function} 309 * @see {@link module:@stdlib/utils/define-memoized-property} 310 */ 311 setReadOnly( utils, 'defineMemoizedProperty', require( './../define-memoized-property' ) ); 312 313 /** 314 * @name setMemoizedReadOnly 315 * @memberof utils 316 * @readonly 317 * @type {Function} 318 * @see {@link module:@stdlib/utils/define-memoized-read-only-property} 319 */ 320 setReadOnly( utils, 'setMemoizedReadOnly', require( './../define-memoized-read-only-property' ) ); 321 322 /** 323 * @name setNonEnumerableProperty 324 * @memberof utils 325 * @readonly 326 * @type {Function} 327 * @see {@link module:@stdlib/utils/define-nonenumerable-property} 328 */ 329 setReadOnly( utils, 'setNonEnumerableProperty', require( './../define-nonenumerable-property' ) ); 330 331 /** 332 * @name setNonEnumerableReadOnlyAccessor 333 * @memberof utils 334 * @readonly 335 * @type {Function} 336 * @see {@link module:@stdlib/utils/define-nonenumerable-read-only-accessor} 337 */ 338 setReadOnly( utils, 'setNonEnumerableReadOnlyAccessor', require( './../define-nonenumerable-read-only-accessor' ) ); 339 340 /** 341 * @name setNonEnumerableReadOnly 342 * @memberof utils 343 * @readonly 344 * @type {Function} 345 * @see {@link module:@stdlib/utils/define-nonenumerable-read-only-property} 346 */ 347 setReadOnly( utils, 'setNonEnumerableReadOnly', require( './../define-nonenumerable-read-only-property' ) ); 348 349 /** 350 * @name setNonEnumerableReadWriteAccessor 351 * @memberof utils 352 * @readonly 353 * @type {Function} 354 * @see {@link module:@stdlib/utils/define-nonenumerable-read-write-accessor} 355 */ 356 setReadOnly( utils, 'setNonEnumerableReadWriteAccessor', require( './../define-nonenumerable-read-write-accessor' ) ); 357 358 /** 359 * @name setNonEnumerableWriteOnlyAccessor 360 * @memberof utils 361 * @readonly 362 * @type {Function} 363 * @see {@link module:@stdlib/utils/define-nonenumerable-write-only-accessor} 364 */ 365 setReadOnly( utils, 'setNonEnumerableWriteOnlyAccessor', require( './../define-nonenumerable-write-only-accessor' ) ); 366 367 /** 368 * @name defineProperties 369 * @memberof utils 370 * @readonly 371 * @type {Function} 372 * @see {@link module:@stdlib/utils/define-properties} 373 */ 374 setReadOnly( utils, 'defineProperties', require( './../define-properties' ) ); 375 376 /** 377 * @name defineProperty 378 * @memberof utils 379 * @readonly 380 * @type {Function} 381 * @see {@link module:@stdlib/utils/define-property} 382 */ 383 setReadOnly( utils, 'defineProperty', require( './../define-property' ) ); 384 385 /** 386 * @name setReadOnlyAccessor 387 * @memberof utils 388 * @readonly 389 * @type {Function} 390 * @see {@link module:@stdlib/utils/define-read-only-accessor} 391 */ 392 setReadOnly( utils, 'setReadOnlyAccessor', require( './../define-read-only-accessor' ) ); 393 394 /** 395 * @name setReadOnly 396 * @memberof utils 397 * @readonly 398 * @type {Function} 399 * @see {@link module:@stdlib/utils/define-read-only-property} 400 */ 401 setReadOnly( utils, 'setReadOnly', require( './../define-read-only-property' ) ); 402 403 /** 404 * @name setReadWriteAccessor 405 * @memberof utils 406 * @readonly 407 * @type {Function} 408 * @see {@link module:@stdlib/utils/define-read-write-accessor} 409 */ 410 setReadOnly( utils, 'setReadWriteAccessor', require( './../define-read-write-accessor' ) ); 411 412 /** 413 * @name setWriteOnlyAccessor 414 * @memberof utils 415 * @readonly 416 * @type {Function} 417 * @see {@link module:@stdlib/utils/define-write-only-accessor} 418 */ 419 setReadOnly( utils, 'setWriteOnlyAccessor', require( './../define-write-only-accessor' ) ); 420 421 /** 422 * @name dirname 423 * @memberof utils 424 * @readonly 425 * @type {Function} 426 * @see {@link module:@stdlib/utils/dirname} 427 */ 428 setReadOnly( utils, 'dirname', require( './../dirname' ) ); 429 430 /** 431 * @name doUntil 432 * @memberof utils 433 * @readonly 434 * @type {Function} 435 * @see {@link module:@stdlib/utils/do-until} 436 */ 437 setReadOnly( utils, 'doUntil', require( './../do-until' ) ); 438 439 /** 440 * @name doUntilEach 441 * @memberof utils 442 * @readonly 443 * @type {Function} 444 * @see {@link module:@stdlib/utils/do-until-each} 445 */ 446 setReadOnly( utils, 'doUntilEach', require( './../do-until-each' ) ); 447 448 /** 449 * @name doUntilEachRight 450 * @memberof utils 451 * @readonly 452 * @type {Function} 453 * @see {@link module:@stdlib/utils/do-until-each-right} 454 */ 455 setReadOnly( utils, 'doUntilEachRight', require( './../do-until-each-right' ) ); 456 457 /** 458 * @name doWhile 459 * @memberof utils 460 * @readonly 461 * @type {Function} 462 * @see {@link module:@stdlib/utils/do-while} 463 */ 464 setReadOnly( utils, 'doWhile', require( './../do-while' ) ); 465 466 /** 467 * @name doWhileEach 468 * @memberof utils 469 * @readonly 470 * @type {Function} 471 * @see {@link module:@stdlib/utils/do-while-each} 472 */ 473 setReadOnly( utils, 'doWhileEach', require( './../do-while-each' ) ); 474 475 /** 476 * @name doWhileEachRight 477 * @memberof utils 478 * @readonly 479 * @type {Function} 480 * @see {@link module:@stdlib/utils/do-while-each-right} 481 */ 482 setReadOnly( utils, 'doWhileEachRight', require( './../do-while-each-right' ) ); 483 484 /** 485 * @name DoublyLinkedList 486 * @memberof utils 487 * @readonly 488 * @type {Function} 489 * @see {@link module:@stdlib/utils/doubly-linked-list} 490 */ 491 setReadOnly( utils, 'DoublyLinkedList', require( './../doubly-linked-list' ) ); 492 493 /** 494 * @name objectEntries 495 * @memberof utils 496 * @readonly 497 * @type {Function} 498 * @see {@link module:@stdlib/utils/entries} 499 */ 500 setReadOnly( utils, 'objectEntries', require( './../entries' ) ); 501 502 /** 503 * @name objectEntriesIn 504 * @memberof utils 505 * @readonly 506 * @type {Function} 507 * @see {@link module:@stdlib/utils/entries-in} 508 */ 509 setReadOnly( utils, 'objectEntriesIn', require( './../entries-in' ) ); 510 511 /** 512 * @name enumerableProperties 513 * @memberof utils 514 * @readonly 515 * @type {Function} 516 * @see {@link module:@stdlib/utils/enumerable-properties} 517 */ 518 setReadOnly( utils, 'enumerableProperties', require( './../enumerable-properties' ) ); 519 520 /** 521 * @name enumerablePropertiesIn 522 * @memberof utils 523 * @readonly 524 * @type {Function} 525 * @see {@link module:@stdlib/utils/enumerable-properties-in} 526 */ 527 setReadOnly( utils, 'enumerablePropertiesIn', require( './../enumerable-properties-in' ) ); 528 529 /** 530 * @name enumerablePropertySymbols 531 * @memberof utils 532 * @readonly 533 * @type {Function} 534 * @see {@link module:@stdlib/utils/enumerable-property-symbols} 535 */ 536 setReadOnly( utils, 'enumerablePropertySymbols', require( './../enumerable-property-symbols' ) ); 537 538 /** 539 * @name enumerablePropertySymbolsIn 540 * @memberof utils 541 * @readonly 542 * @type {Function} 543 * @see {@link module:@stdlib/utils/enumerable-property-symbols-in} 544 */ 545 setReadOnly( utils, 'enumerablePropertySymbolsIn', require( './../enumerable-property-symbols-in' ) ); 546 547 /** 548 * @name rescape 549 * @memberof utils 550 * @readonly 551 * @type {Function} 552 * @see {@link module:@stdlib/utils/escape-regexp-string} 553 */ 554 setReadOnly( utils, 'rescape', require( './../escape-regexp-string' ) ); 555 556 /** 557 * @name evil 558 * @memberof utils 559 * @readonly 560 * @type {Function} 561 * @see {@link module:@stdlib/utils/eval} 562 */ 563 setReadOnly( utils, 'evil', require( './../eval' ) ); 564 565 /** 566 * @name every 567 * @memberof utils 568 * @readonly 569 * @type {Function} 570 * @see {@link module:@stdlib/utils/every} 571 */ 572 setReadOnly( utils, 'every', require( './../every' ) ); 573 574 /** 575 * @name everyBy 576 * @memberof utils 577 * @readonly 578 * @type {Function} 579 * @see {@link module:@stdlib/utils/every-by} 580 */ 581 setReadOnly( utils, 'everyBy', require( './../every-by' ) ); 582 583 /** 584 * @name everyByRight 585 * @memberof utils 586 * @readonly 587 * @type {Function} 588 * @see {@link module:@stdlib/utils/every-by-right} 589 */ 590 setReadOnly( utils, 'everyByRight', require( './../every-by-right' ) ); 591 592 /** 593 * @name extname 594 * @memberof utils 595 * @readonly 596 * @type {Function} 597 * @see {@link module:@stdlib/utils/extname} 598 */ 599 setReadOnly( utils, 'extname', require( './../extname' ) ); 600 601 /** 602 * @name FIFO 603 * @memberof utils 604 * @readonly 605 * @type {Function} 606 * @see {@link module:@stdlib/utils/fifo} 607 */ 608 setReadOnly( utils, 'FIFO', require( './../fifo' ) ); 609 610 /** 611 * @name find 612 * @memberof utils 613 * @readonly 614 * @type {Function} 615 * @see {@link module:@stdlib/utils/find} 616 */ 617 setReadOnly( utils, 'find', require( './../find' ) ); 618 619 /** 620 * @name flattenArray 621 * @memberof utils 622 * @readonly 623 * @type {Function} 624 * @see {@link module:@stdlib/utils/flatten-array} 625 */ 626 setReadOnly( utils, 'flattenArray', require( './../flatten-array' ) ); 627 628 /** 629 * @name flattenObject 630 * @memberof utils 631 * @readonly 632 * @type {Function} 633 * @see {@link module:@stdlib/utils/flatten-object} 634 */ 635 setReadOnly( utils, 'flattenObject', require( './../flatten-object' ) ); 636 637 /** 638 * @name forEach 639 * @memberof utils 640 * @readonly 641 * @type {Function} 642 * @see {@link module:@stdlib/utils/for-each} 643 */ 644 setReadOnly( utils, 'forEach', require( './../for-each' ) ); 645 646 /** 647 * @name forEachRight 648 * @memberof utils 649 * @readonly 650 * @type {Function} 651 * @see {@link module:@stdlib/utils/for-each-right} 652 */ 653 setReadOnly( utils, 'forEachRight', require( './../for-each-right' ) ); 654 655 /** 656 * @name forIn 657 * @memberof utils 658 * @readonly 659 * @type {Function} 660 * @see {@link module:@stdlib/utils/for-in} 661 */ 662 setReadOnly( utils, 'forIn', require( './../for-in' ) ); 663 664 /** 665 * @name forOwn 666 * @memberof utils 667 * @readonly 668 * @type {Function} 669 * @see {@link module:@stdlib/utils/for-own} 670 */ 671 setReadOnly( utils, 'forOwn', require( './../for-own' ) ); 672 673 /** 674 * @name objectFromEntries 675 * @memberof utils 676 * @readonly 677 * @type {Function} 678 * @see {@link module:@stdlib/utils/from-entries} 679 */ 680 setReadOnly( utils, 'objectFromEntries', require( './../from-entries' ) ); 681 682 /** 683 * @name functionName 684 * @memberof utils 685 * @readonly 686 * @type {Function} 687 * @see {@link module:@stdlib/utils/function-name} 688 */ 689 setReadOnly( utils, 'functionName', require( './../function-name' ) ); 690 691 /** 692 * @name functionSequence 693 * @memberof utils 694 * @readonly 695 * @type {Function} 696 * @see {@link module:@stdlib/utils/function-sequence} 697 */ 698 setReadOnly( utils, 'functionSequence', require( './../function-sequence' ) ); 699 700 /** 701 * @name getPrototypeOf 702 * @memberof utils 703 * @readonly 704 * @type {Function} 705 * @see {@link module:@stdlib/utils/get-prototype-of} 706 */ 707 setReadOnly( utils, 'getPrototypeOf', require( './../get-prototype-of' ) ); 708 709 /** 710 * @name getGlobal 711 * @memberof utils 712 * @readonly 713 * @type {Function} 714 * @see {@link module:@stdlib/utils/global} 715 */ 716 setReadOnly( utils, 'getGlobal', require( './../global' ) ); 717 718 /** 719 * @name group 720 * @memberof utils 721 * @readonly 722 * @type {Function} 723 * @see {@link module:@stdlib/utils/group} 724 */ 725 setReadOnly( utils, 'group', require( './../group' ) ); 726 727 /** 728 * @name groupBy 729 * @memberof utils 730 * @readonly 731 * @type {Function} 732 * @see {@link module:@stdlib/utils/group-by} 733 */ 734 setReadOnly( utils, 'groupBy', require( './../group-by' ) ); 735 736 /** 737 * @name groupIn 738 * @memberof utils 739 * @readonly 740 * @type {Function} 741 * @see {@link module:@stdlib/utils/group-in} 742 */ 743 setReadOnly( utils, 'groupIn', require( './../group-in' ) ); 744 745 /** 746 * @name groupOwn 747 * @memberof utils 748 * @readonly 749 * @type {Function} 750 * @see {@link module:@stdlib/utils/group-own} 751 */ 752 setReadOnly( utils, 'groupOwn', require( './../group-own' ) ); 753 754 /** 755 * @name identity 756 * @memberof utils 757 * @readonly 758 * @type {Function} 759 * @see {@link module:@stdlib/utils/identity-function} 760 */ 761 setReadOnly( utils, 'identity', require( './../identity-function' ) ); 762 763 /** 764 * @name ifelse 765 * @memberof utils 766 * @readonly 767 * @type {Function} 768 * @see {@link module:@stdlib/utils/if-else} 769 */ 770 setReadOnly( utils, 'ifelse', require( './../if-else' ) ); 771 772 /** 773 * @name ifthen 774 * @memberof utils 775 * @readonly 776 * @type {Function} 777 * @see {@link module:@stdlib/utils/if-then} 778 */ 779 setReadOnly( utils, 'ifthen', require( './../if-then' ) ); 780 781 /** 782 * @name indexOf 783 * @memberof utils 784 * @readonly 785 * @type {Function} 786 * @see {@link module:@stdlib/utils/index-of} 787 */ 788 setReadOnly( utils, 'indexOf', require( './../index-of' ) ); 789 790 /** 791 * @name inherit 792 * @memberof utils 793 * @readonly 794 * @type {Function} 795 * @see {@link module:@stdlib/utils/inherit} 796 */ 797 setReadOnly( utils, 'inherit', require( './../inherit' ) ); 798 799 /** 800 * @name inheritedEnumerableProperties 801 * @memberof utils 802 * @readonly 803 * @type {Function} 804 * @see {@link module:@stdlib/utils/inherited-enumerable-properties} 805 */ 806 setReadOnly( utils, 'inheritedEnumerableProperties', require( './../inherited-enumerable-properties' ) ); 807 808 /** 809 * @name inheritedEnumerablePropertySymbols 810 * @memberof utils 811 * @readonly 812 * @type {Function} 813 * @see {@link module:@stdlib/utils/inherited-enumerable-property-symbols} 814 */ 815 setReadOnly( utils, 'inheritedEnumerablePropertySymbols', require( './../inherited-enumerable-property-symbols' ) ); 816 817 /** 818 * @name inheritedKeys 819 * @memberof utils 820 * @readonly 821 * @type {Function} 822 * @see {@link module:@stdlib/utils/inherited-keys} 823 */ 824 setReadOnly( utils, 'inheritedKeys', require( './../inherited-keys' ) ); 825 826 /** 827 * @name inheritedNonEnumerableProperties 828 * @memberof utils 829 * @readonly 830 * @type {Function} 831 * @see {@link module:@stdlib/utils/inherited-nonenumerable-properties} 832 */ 833 setReadOnly( utils, 'inheritedNonEnumerableProperties', require( './../inherited-nonenumerable-properties' ) ); 834 835 /** 836 * @name inheritedNonEnumerablePropertyNames 837 * @memberof utils 838 * @readonly 839 * @type {Function} 840 * @see {@link module:@stdlib/utils/inherited-nonenumerable-property-names} 841 */ 842 setReadOnly( utils, 'inheritedNonEnumerablePropertyNames', require( './../inherited-nonenumerable-property-names' ) ); 843 844 /** 845 * @name inheritedNonEnumerablePropertySymbols 846 * @memberof utils 847 * @readonly 848 * @type {Function} 849 * @see {@link module:@stdlib/utils/inherited-nonenumerable-property-symbols} 850 */ 851 setReadOnly( utils, 'inheritedNonEnumerablePropertySymbols', require( './../inherited-nonenumerable-property-symbols' ) ); 852 853 /** 854 * @name inheritedProperties 855 * @memberof utils 856 * @readonly 857 * @type {Function} 858 * @see {@link module:@stdlib/utils/inherited-properties} 859 */ 860 setReadOnly( utils, 'inheritedProperties', require( './../inherited-properties' ) ); 861 862 /** 863 * @name inheritedPropertyDescriptor 864 * @memberof utils 865 * @readonly 866 * @type {Function} 867 * @see {@link module:@stdlib/utils/inherited-property-descriptor} 868 */ 869 setReadOnly( utils, 'inheritedPropertyDescriptor', require( './../inherited-property-descriptor' ) ); 870 871 /** 872 * @name inheritedPropertyDescriptors 873 * @memberof utils 874 * @readonly 875 * @type {Function} 876 * @see {@link module:@stdlib/utils/inherited-property-descriptors} 877 */ 878 setReadOnly( utils, 'inheritedPropertyDescriptors', require( './../inherited-property-descriptors' ) ); 879 880 /** 881 * @name inheritedPropertyNames 882 * @memberof utils 883 * @readonly 884 * @type {Function} 885 * @see {@link module:@stdlib/utils/inherited-property-names} 886 */ 887 setReadOnly( utils, 'inheritedPropertyNames', require( './../inherited-property-names' ) ); 888 889 /** 890 * @name inheritedPropertySymbols 891 * @memberof utils 892 * @readonly 893 * @type {Function} 894 * @see {@link module:@stdlib/utils/inherited-property-symbols} 895 */ 896 setReadOnly( utils, 'inheritedPropertySymbols', require( './../inherited-property-symbols' ) ); 897 898 /** 899 * @name inheritedWritableProperties 900 * @memberof utils 901 * @readonly 902 * @type {Function} 903 * @see {@link module:@stdlib/utils/inherited-writable-properties} 904 */ 905 setReadOnly( utils, 'inheritedWritableProperties', require( './../inherited-writable-properties' ) ); 906 907 /** 908 * @name inheritedWritablePropertyNames 909 * @memberof utils 910 * @readonly 911 * @type {Function} 912 * @see {@link module:@stdlib/utils/inherited-writable-property-names} 913 */ 914 setReadOnly( utils, 'inheritedWritablePropertyNames', require( './../inherited-writable-property-names' ) ); 915 916 /** 917 * @name inheritedWritablePropertySymbols 918 * @memberof utils 919 * @readonly 920 * @type {Function} 921 * @see {@link module:@stdlib/utils/inherited-writable-property-symbols} 922 */ 923 setReadOnly( utils, 'inheritedWritablePropertySymbols', require( './../inherited-writable-property-symbols' ) ); 924 925 /** 926 * @name inmap 927 * @memberof utils 928 * @readonly 929 * @type {Function} 930 * @see {@link module:@stdlib/utils/inmap} 931 */ 932 setReadOnly( utils, 'inmap', require( './../inmap' ) ); 933 934 /** 935 * @name inmapRight 936 * @memberof utils 937 * @readonly 938 * @type {Function} 939 * @see {@link module:@stdlib/utils/inmap-right} 940 */ 941 setReadOnly( utils, 'inmapRight', require( './../inmap-right' ) ); 942 943 /** 944 * @name keyBy 945 * @memberof utils 946 * @readonly 947 * @type {Function} 948 * @see {@link module:@stdlib/utils/key-by} 949 */ 950 setReadOnly( utils, 'keyBy', require( './../key-by' ) ); 951 952 /** 953 * @name keyByRight 954 * @memberof utils 955 * @readonly 956 * @type {Function} 957 * @see {@link module:@stdlib/utils/key-by-right} 958 */ 959 setReadOnly( utils, 'keyByRight', require( './../key-by-right' ) ); 960 961 /** 962 * @name objectKeys 963 * @memberof utils 964 * @readonly 965 * @type {Function} 966 * @see {@link module:@stdlib/utils/keys} 967 */ 968 setReadOnly( utils, 'objectKeys', require( './../keys' ) ); 969 970 /** 971 * @name keysIn 972 * @memberof utils 973 * @readonly 974 * @type {Function} 975 * @see {@link module:@stdlib/utils/keys-in} 976 */ 977 setReadOnly( utils, 'keysIn', require( './../keys-in' ) ); 978 979 /** 980 * @name LinkedList 981 * @memberof utils 982 * @readonly 983 * @type {Function} 984 * @see {@link module:@stdlib/utils/linked-list} 985 */ 986 setReadOnly( utils, 'LinkedList', require( './../linked-list' ) ); 987 988 /** 989 * @name lowercaseKeys 990 * @memberof utils 991 * @readonly 992 * @type {Function} 993 * @see {@link module:@stdlib/utils/lowercase-keys} 994 */ 995 setReadOnly( utils, 'lowercaseKeys', require( './../lowercase-keys' ) ); 996 997 /** 998 * @name mapFun 999 * @memberof utils 1000 * @readonly 1001 * @type {Function} 1002 * @see {@link module:@stdlib/utils/map-function} 1003 */ 1004 setReadOnly( utils, 'mapFun', require( './../map-function' ) ); 1005 1006 /** 1007 * @name mapKeys 1008 * @memberof utils 1009 * @readonly 1010 * @type {Function} 1011 * @see {@link module:@stdlib/utils/map-keys} 1012 */ 1013 setReadOnly( utils, 'mapKeys', require( './../map-keys' ) ); 1014 1015 /** 1016 * @name mapValues 1017 * @memberof utils 1018 * @readonly 1019 * @type {Function} 1020 * @see {@link module:@stdlib/utils/map-values} 1021 */ 1022 setReadOnly( utils, 'mapValues', require( './../map-values' ) ); 1023 1024 /** 1025 * @name memoize 1026 * @memberof utils 1027 * @readonly 1028 * @type {Function} 1029 * @see {@link module:@stdlib/utils/memoize} 1030 */ 1031 setReadOnly( utils, 'memoize', require( './../memoize' ) ); 1032 1033 /** 1034 * @name merge 1035 * @memberof utils 1036 * @readonly 1037 * @type {Function} 1038 * @see {@link module:@stdlib/utils/merge} 1039 */ 1040 setReadOnly( utils, 'merge', require( './../merge' ) ); 1041 1042 /** 1043 * @name moveProperty 1044 * @memberof utils 1045 * @readonly 1046 * @type {Function} 1047 * @see {@link module:@stdlib/utils/move-property} 1048 */ 1049 setReadOnly( utils, 'moveProperty', require( './../move-property' ) ); 1050 1051 /** 1052 * @name namedtypedtuple 1053 * @memberof utils 1054 * @readonly 1055 * @type {Function} 1056 * @see {@link module:@stdlib/utils/named-typed-tuple} 1057 */ 1058 setReadOnly( utils, 'namedtypedtuple', require( './../named-typed-tuple' ) ); 1059 1060 /** 1061 * @name nativeClass 1062 * @memberof utils 1063 * @readonly 1064 * @type {Function} 1065 * @see {@link module:@stdlib/utils/native-class} 1066 */ 1067 setReadOnly( utils, 'nativeClass', require( './../native-class' ) ); 1068 1069 /** 1070 * @name nextTick 1071 * @memberof utils 1072 * @readonly 1073 * @type {Function} 1074 * @see {@link module:@stdlib/utils/next-tick} 1075 */ 1076 setReadOnly( utils, 'nextTick', require( './../next-tick' ) ); 1077 1078 /** 1079 * @name none 1080 * @memberof utils 1081 * @readonly 1082 * @type {Function} 1083 * @see {@link module:@stdlib/utils/none} 1084 */ 1085 setReadOnly( utils, 'none', require( './../none' ) ); 1086 1087 /** 1088 * @name noneBy 1089 * @memberof utils 1090 * @readonly 1091 * @type {Function} 1092 * @see {@link module:@stdlib/utils/none-by} 1093 */ 1094 setReadOnly( utils, 'noneBy', require( './../none-by' ) ); 1095 1096 /** 1097 * @name noneByRight 1098 * @memberof utils 1099 * @readonly 1100 * @type {Function} 1101 * @see {@link module:@stdlib/utils/none-by-right} 1102 */ 1103 setReadOnly( utils, 'noneByRight', require( './../none-by-right' ) ); 1104 1105 /** 1106 * @name nonEnumerableProperties 1107 * @memberof utils 1108 * @readonly 1109 * @type {Function} 1110 * @see {@link module:@stdlib/utils/nonenumerable-properties} 1111 */ 1112 setReadOnly( utils, 'nonEnumerableProperties', require( './../nonenumerable-properties' ) ); 1113 1114 /** 1115 * @name nonEnumerablePropertiesIn 1116 * @memberof utils 1117 * @readonly 1118 * @type {Function} 1119 * @see {@link module:@stdlib/utils/nonenumerable-properties-in} 1120 */ 1121 setReadOnly( utils, 'nonEnumerablePropertiesIn', require( './../nonenumerable-properties-in' ) ); 1122 1123 /** 1124 * @name nonEnumerablePropertyNames 1125 * @memberof utils 1126 * @readonly 1127 * @type {Function} 1128 * @see {@link module:@stdlib/utils/nonenumerable-property-names} 1129 */ 1130 setReadOnly( utils, 'nonEnumerablePropertyNames', require( './../nonenumerable-property-names' ) ); 1131 1132 /** 1133 * @name nonEnumerablePropertyNamesIn 1134 * @memberof utils 1135 * @readonly 1136 * @type {Function} 1137 * @see {@link module:@stdlib/utils/nonenumerable-property-names-in} 1138 */ 1139 setReadOnly( utils, 'nonEnumerablePropertyNamesIn', require( './../nonenumerable-property-names-in' ) ); 1140 1141 /** 1142 * @name nonEnumerablePropertySymbols 1143 * @memberof utils 1144 * @readonly 1145 * @type {Function} 1146 * @see {@link module:@stdlib/utils/nonenumerable-property-symbols} 1147 */ 1148 setReadOnly( utils, 'nonEnumerablePropertySymbols', require( './../nonenumerable-property-symbols' ) ); 1149 1150 /** 1151 * @name nonEnumerablePropertySymbolsIn 1152 * @memberof utils 1153 * @readonly 1154 * @type {Function} 1155 * @see {@link module:@stdlib/utils/nonenumerable-property-symbols-in} 1156 */ 1157 setReadOnly( utils, 'nonEnumerablePropertySymbolsIn', require( './../nonenumerable-property-symbols-in' ) ); 1158 1159 /** 1160 * @name nonIndexKeys 1161 * @memberof utils 1162 * @readonly 1163 * @type {Function} 1164 * @see {@link module:@stdlib/utils/nonindex-keys} 1165 */ 1166 setReadOnly( utils, 'nonIndexKeys', require( './../nonindex-keys' ) ); 1167 1168 /** 1169 * @name noop 1170 * @memberof utils 1171 * @readonly 1172 * @type {Function} 1173 * @see {@link module:@stdlib/utils/noop} 1174 */ 1175 setReadOnly( utils, 'noop', require( './../noop' ) ); 1176 1177 /** 1178 * @name objectInverse 1179 * @memberof utils 1180 * @readonly 1181 * @type {Function} 1182 * @see {@link module:@stdlib/utils/object-inverse} 1183 */ 1184 setReadOnly( utils, 'objectInverse', require( './../object-inverse' ) ); 1185 1186 /** 1187 * @name objectInverseBy 1188 * @memberof utils 1189 * @readonly 1190 * @type {Function} 1191 * @see {@link module:@stdlib/utils/object-inverse-by} 1192 */ 1193 setReadOnly( utils, 'objectInverseBy', require( './../object-inverse-by' ) ); 1194 1195 /** 1196 * @name omit 1197 * @memberof utils 1198 * @readonly 1199 * @type {Function} 1200 * @see {@link module:@stdlib/utils/omit} 1201 */ 1202 setReadOnly( utils, 'omit', require( './../omit' ) ); 1203 1204 /** 1205 * @name omitBy 1206 * @memberof utils 1207 * @readonly 1208 * @type {Function} 1209 * @see {@link module:@stdlib/utils/omit-by} 1210 */ 1211 setReadOnly( utils, 'omitBy', require( './../omit-by' ) ); 1212 1213 /** 1214 * @name openURL 1215 * @memberof utils 1216 * @readonly 1217 * @type {Function} 1218 * @see {@link module:@stdlib/utils/open-url} 1219 */ 1220 setReadOnly( utils, 'openURL', require( './../open-url' ) ); 1221 1222 /** 1223 * @name papply 1224 * @memberof utils 1225 * @readonly 1226 * @type {Function} 1227 * @see {@link module:@stdlib/utils/papply} 1228 */ 1229 setReadOnly( utils, 'papply', require( './../papply' ) ); 1230 1231 /** 1232 * @name papplyRight 1233 * @memberof utils 1234 * @readonly 1235 * @type {Function} 1236 * @see {@link module:@stdlib/utils/papply-right} 1237 */ 1238 setReadOnly( utils, 'papplyRight', require( './../papply-right' ) ); 1239 1240 /** 1241 * @name parallel 1242 * @memberof utils 1243 * @readonly 1244 * @type {Function} 1245 * @see {@link module:@stdlib/utils/parallel} 1246 */ 1247 setReadOnly( utils, 'parallel', require( './../parallel' ) ); 1248 1249 /** 1250 * @name parseJSON 1251 * @memberof utils 1252 * @readonly 1253 * @type {Function} 1254 * @see {@link module:@stdlib/utils/parse-json} 1255 */ 1256 setReadOnly( utils, 'parseJSON', require( './../parse-json' ) ); 1257 1258 /** 1259 * @name pick 1260 * @memberof utils 1261 * @readonly 1262 * @type {Function} 1263 * @see {@link module:@stdlib/utils/pick} 1264 */ 1265 setReadOnly( utils, 'pick', require( './../pick' ) ); 1266 1267 /** 1268 * @name pickBy 1269 * @memberof utils 1270 * @readonly 1271 * @type {Function} 1272 * @see {@link module:@stdlib/utils/pick-by} 1273 */ 1274 setReadOnly( utils, 'pickBy', require( './../pick-by' ) ); 1275 1276 /** 1277 * @name pluck 1278 * @memberof utils 1279 * @readonly 1280 * @type {Function} 1281 * @see {@link module:@stdlib/utils/pluck} 1282 */ 1283 setReadOnly( utils, 'pluck', require( './../pluck' ) ); 1284 1285 /** 1286 * @name pop 1287 * @memberof utils 1288 * @readonly 1289 * @type {Function} 1290 * @see {@link module:@stdlib/utils/pop} 1291 */ 1292 setReadOnly( utils, 'pop', require( './../pop' ) ); 1293 1294 /** 1295 * @name prepend 1296 * @memberof utils 1297 * @readonly 1298 * @type {Function} 1299 * @see {@link module:@stdlib/utils/prepend} 1300 */ 1301 setReadOnly( utils, 'prepend', require( './../prepend' ) ); 1302 1303 /** 1304 * @name properties 1305 * @memberof utils 1306 * @readonly 1307 * @type {Function} 1308 * @see {@link module:@stdlib/utils/properties} 1309 */ 1310 setReadOnly( utils, 'properties', require( './../properties' ) ); 1311 1312 /** 1313 * @name propertiesIn 1314 * @memberof utils 1315 * @readonly 1316 * @type {Function} 1317 * @see {@link module:@stdlib/utils/properties-in} 1318 */ 1319 setReadOnly( utils, 'propertiesIn', require( './../properties-in' ) ); 1320 1321 /** 1322 * @name propertyDescriptor 1323 * @memberof utils 1324 * @readonly 1325 * @type {Function} 1326 * @see {@link module:@stdlib/utils/property-descriptor} 1327 */ 1328 setReadOnly( utils, 'propertyDescriptor', require( './../property-descriptor' ) ); 1329 1330 /** 1331 * @name propertyDescriptorIn 1332 * @memberof utils 1333 * @readonly 1334 * @type {Function} 1335 * @see {@link module:@stdlib/utils/property-descriptor-in} 1336 */ 1337 setReadOnly( utils, 'propertyDescriptorIn', require( './../property-descriptor-in' ) ); 1338 1339 /** 1340 * @name propertyDescriptors 1341 * @memberof utils 1342 * @readonly 1343 * @type {Function} 1344 * @see {@link module:@stdlib/utils/property-descriptors} 1345 */ 1346 setReadOnly( utils, 'propertyDescriptors', require( './../property-descriptors' ) ); 1347 1348 /** 1349 * @name propertyDescriptorsIn 1350 * @memberof utils 1351 * @readonly 1352 * @type {Function} 1353 * @see {@link module:@stdlib/utils/property-descriptors-in} 1354 */ 1355 setReadOnly( utils, 'propertyDescriptorsIn', require( './../property-descriptors-in' ) ); 1356 1357 /** 1358 * @name propertyNames 1359 * @memberof utils 1360 * @readonly 1361 * @type {Function} 1362 * @see {@link module:@stdlib/utils/property-names} 1363 */ 1364 setReadOnly( utils, 'propertyNames', require( './../property-names' ) ); 1365 1366 /** 1367 * @name propertyNamesIn 1368 * @memberof utils 1369 * @readonly 1370 * @type {Function} 1371 * @see {@link module:@stdlib/utils/property-names-in} 1372 */ 1373 setReadOnly( utils, 'propertyNamesIn', require( './../property-names-in' ) ); 1374 1375 /** 1376 * @name propertySymbols 1377 * @memberof utils 1378 * @readonly 1379 * @type {Function} 1380 * @see {@link module:@stdlib/utils/property-symbols} 1381 */ 1382 setReadOnly( utils, 'propertySymbols', require( './../property-symbols' ) ); 1383 1384 /** 1385 * @name propertySymbolsIn 1386 * @memberof utils 1387 * @readonly 1388 * @type {Function} 1389 * @see {@link module:@stdlib/utils/property-symbols-in} 1390 */ 1391 setReadOnly( utils, 'propertySymbolsIn', require( './../property-symbols-in' ) ); 1392 1393 /** 1394 * @name push 1395 * @memberof utils 1396 * @readonly 1397 * @type {Function} 1398 * @see {@link module:@stdlib/utils/push} 1399 */ 1400 setReadOnly( utils, 'push', require( './../push' ) ); 1401 1402 /** 1403 * @name realmax 1404 * @memberof utils 1405 * @readonly 1406 * @type {Function} 1407 * @see {@link module:@stdlib/utils/real-max} 1408 */ 1409 setReadOnly( utils, 'realmax', require( './../real-max' ) ); 1410 1411 /** 1412 * @name realmin 1413 * @memberof utils 1414 * @readonly 1415 * @type {Function} 1416 * @see {@link module:@stdlib/utils/real-min} 1417 */ 1418 setReadOnly( utils, 'realmin', require( './../real-min' ) ); 1419 1420 /** 1421 * @name reduce 1422 * @memberof utils 1423 * @readonly 1424 * @type {Function} 1425 * @see {@link module:@stdlib/utils/reduce} 1426 */ 1427 setReadOnly( utils, 'reduce', require( './../reduce' ) ); 1428 1429 /** 1430 * @name reduceRight 1431 * @memberof utils 1432 * @readonly 1433 * @type {Function} 1434 * @see {@link module:@stdlib/utils/reduce-right} 1435 */ 1436 setReadOnly( utils, 'reduceRight', require( './../reduce-right' ) ); 1437 1438 /** 1439 * @name reFromString 1440 * @memberof utils 1441 * @readonly 1442 * @type {Function} 1443 * @see {@link module:@stdlib/utils/regexp-from-string} 1444 */ 1445 setReadOnly( utils, 'reFromString', require( './../regexp-from-string' ) ); 1446 1447 /** 1448 * @name reorderArguments 1449 * @memberof utils 1450 * @readonly 1451 * @type {Function} 1452 * @see {@link module:@stdlib/utils/reorder-arguments} 1453 */ 1454 setReadOnly( utils, 'reorderArguments', require( './../reorder-arguments' ) ); 1455 1456 /** 1457 * @name reverseArguments 1458 * @memberof utils 1459 * @readonly 1460 * @type {Function} 1461 * @see {@link module:@stdlib/utils/reverse-arguments} 1462 */ 1463 setReadOnly( utils, 'reverseArguments', require( './../reverse-arguments' ) ); 1464 1465 /** 1466 * @name safeintmax 1467 * @memberof utils 1468 * @readonly 1469 * @type {Function} 1470 * @see {@link module:@stdlib/utils/safe-int-max} 1471 */ 1472 setReadOnly( utils, 'safeintmax', require( './../safe-int-max' ) ); 1473 1474 /** 1475 * @name safeintmin 1476 * @memberof utils 1477 * @readonly 1478 * @type {Function} 1479 * @see {@link module:@stdlib/utils/safe-int-min} 1480 */ 1481 setReadOnly( utils, 'safeintmin', require( './../safe-int-min' ) ); 1482 1483 /** 1484 * @name shift 1485 * @memberof utils 1486 * @readonly 1487 * @type {Function} 1488 * @see {@link module:@stdlib/utils/shift} 1489 */ 1490 setReadOnly( utils, 'shift', require( './../shift' ) ); 1491 1492 /** 1493 * @name sizeOf 1494 * @memberof utils 1495 * @readonly 1496 * @type {Function} 1497 * @see {@link module:@stdlib/utils/size-of} 1498 */ 1499 setReadOnly( utils, 'sizeOf', require( './../size-of' ) ); 1500 1501 /** 1502 * @name some 1503 * @memberof utils 1504 * @readonly 1505 * @type {Function} 1506 * @see {@link module:@stdlib/utils/some} 1507 */ 1508 setReadOnly( utils, 'some', require( './../some' ) ); 1509 1510 /** 1511 * @name someBy 1512 * @memberof utils 1513 * @readonly 1514 * @type {Function} 1515 * @see {@link module:@stdlib/utils/some-by} 1516 */ 1517 setReadOnly( utils, 'someBy', require( './../some-by' ) ); 1518 1519 /** 1520 * @name someByRight 1521 * @memberof utils 1522 * @readonly 1523 * @type {Function} 1524 * @see {@link module:@stdlib/utils/some-by-right} 1525 */ 1526 setReadOnly( utils, 'someByRight', require( './../some-by-right' ) ); 1527 1528 /** 1529 * @name Stack 1530 * @memberof utils 1531 * @readonly 1532 * @type {Function} 1533 * @see {@link module:@stdlib/utils/stack} 1534 */ 1535 setReadOnly( utils, 'Stack', require( './../stack' ) ); 1536 1537 /** 1538 * @name tabulate 1539 * @memberof utils 1540 * @readonly 1541 * @type {Function} 1542 * @see {@link module:@stdlib/utils/tabulate} 1543 */ 1544 setReadOnly( utils, 'tabulate', require( './../tabulate' ) ); 1545 1546 /** 1547 * @name tabulateBy 1548 * @memberof utils 1549 * @readonly 1550 * @type {Function} 1551 * @see {@link module:@stdlib/utils/tabulate-by} 1552 */ 1553 setReadOnly( utils, 'tabulateBy', require( './../tabulate-by' ) ); 1554 1555 /** 1556 * @name timeit 1557 * @memberof utils 1558 * @readonly 1559 * @type {Function} 1560 * @see {@link module:@stdlib/utils/timeit} 1561 */ 1562 setReadOnly( utils, 'timeit', require( './../timeit' ) ); 1563 1564 /** 1565 * @name trycatch 1566 * @memberof utils 1567 * @readonly 1568 * @type {Function} 1569 * @see {@link module:@stdlib/utils/try-catch} 1570 */ 1571 setReadOnly( utils, 'trycatch', require( './../try-catch' ) ); 1572 1573 /** 1574 * @name tryFunction 1575 * @memberof utils 1576 * @readonly 1577 * @type {Function} 1578 * @see {@link module:@stdlib/utils/try-function} 1579 */ 1580 setReadOnly( utils, 'tryFunction', require( './../try-function' ) ); 1581 1582 /** 1583 * @name tryRequire 1584 * @memberof utils 1585 * @readonly 1586 * @type {Function} 1587 * @see {@link module:@stdlib/utils/try-require} 1588 */ 1589 setReadOnly( utils, 'tryRequire', require( './../try-require' ) ); 1590 1591 /** 1592 * @name trythen 1593 * @memberof utils 1594 * @readonly 1595 * @type {Function} 1596 * @see {@link module:@stdlib/utils/try-then} 1597 */ 1598 setReadOnly( utils, 'trythen', require( './../try-then' ) ); 1599 1600 /** 1601 * @name typemax 1602 * @memberof utils 1603 * @readonly 1604 * @type {Function} 1605 * @see {@link module:@stdlib/utils/type-max} 1606 */ 1607 setReadOnly( utils, 'typemax', require( './../type-max' ) ); 1608 1609 /** 1610 * @name typemin 1611 * @memberof utils 1612 * @readonly 1613 * @type {Function} 1614 * @see {@link module:@stdlib/utils/type-min} 1615 */ 1616 setReadOnly( utils, 'typemin', require( './../type-min' ) ); 1617 1618 /** 1619 * @name typeOf 1620 * @memberof utils 1621 * @readonly 1622 * @type {Function} 1623 * @see {@link module:@stdlib/utils/type-of} 1624 */ 1625 setReadOnly( utils, 'typeOf', require( './../type-of' ) ); 1626 1627 /** 1628 * @name uncapitalizeKeys 1629 * @memberof utils 1630 * @readonly 1631 * @type {Function} 1632 * @see {@link module:@stdlib/utils/uncapitalize-keys} 1633 */ 1634 setReadOnly( utils, 'uncapitalizeKeys', require( './../uncapitalize-keys' ) ); 1635 1636 /** 1637 * @name uncurry 1638 * @memberof utils 1639 * @readonly 1640 * @type {Function} 1641 * @see {@link module:@stdlib/utils/uncurry} 1642 */ 1643 setReadOnly( utils, 'uncurry', require( './../uncurry' ) ); 1644 1645 /** 1646 * @name uncurryRight 1647 * @memberof utils 1648 * @readonly 1649 * @type {Function} 1650 * @see {@link module:@stdlib/utils/uncurry-right} 1651 */ 1652 setReadOnly( utils, 'uncurryRight', require( './../uncurry-right' ) ); 1653 1654 /** 1655 * @name unshift 1656 * @memberof utils 1657 * @readonly 1658 * @type {Function} 1659 * @see {@link module:@stdlib/utils/unshift} 1660 */ 1661 setReadOnly( utils, 'unshift', require( './../unshift' ) ); 1662 1663 /** 1664 * @name until 1665 * @memberof utils 1666 * @readonly 1667 * @type {Function} 1668 * @see {@link module:@stdlib/utils/until} 1669 */ 1670 setReadOnly( utils, 'until', require( './../until' ) ); 1671 1672 /** 1673 * @name untilEach 1674 * @memberof utils 1675 * @readonly 1676 * @type {Function} 1677 * @see {@link module:@stdlib/utils/until-each} 1678 */ 1679 setReadOnly( utils, 'untilEach', require( './../until-each' ) ); 1680 1681 /** 1682 * @name untilEachRight 1683 * @memberof utils 1684 * @readonly 1685 * @type {Function} 1686 * @see {@link module:@stdlib/utils/until-each-right} 1687 */ 1688 setReadOnly( utils, 'untilEachRight', require( './../until-each-right' ) ); 1689 1690 /** 1691 * @name unzip 1692 * @memberof utils 1693 * @readonly 1694 * @type {Function} 1695 * @see {@link module:@stdlib/utils/unzip} 1696 */ 1697 setReadOnly( utils, 'unzip', require( './../unzip' ) ); 1698 1699 /** 1700 * @name uppercaseKeys 1701 * @memberof utils 1702 * @readonly 1703 * @type {Function} 1704 * @see {@link module:@stdlib/utils/uppercase-keys} 1705 */ 1706 setReadOnly( utils, 'uppercaseKeys', require( './../uppercase-keys' ) ); 1707 1708 /** 1709 * @name objectValues 1710 * @memberof utils 1711 * @readonly 1712 * @type {Function} 1713 * @see {@link module:@stdlib/utils/values} 1714 */ 1715 setReadOnly( utils, 'objectValues', require( './../values' ) ); 1716 1717 /** 1718 * @name objectValuesIn 1719 * @memberof utils 1720 * @readonly 1721 * @type {Function} 1722 * @see {@link module:@stdlib/utils/values-in} 1723 */ 1724 setReadOnly( utils, 'objectValuesIn', require( './../values-in' ) ); 1725 1726 /** 1727 * @name whilst 1728 * @memberof utils 1729 * @readonly 1730 * @type {Function} 1731 * @see {@link module:@stdlib/utils/while} 1732 */ 1733 setReadOnly( utils, 'whilst', require( './../while' ) ); 1734 1735 /** 1736 * @name whileEach 1737 * @memberof utils 1738 * @readonly 1739 * @type {Function} 1740 * @see {@link module:@stdlib/utils/while-each} 1741 */ 1742 setReadOnly( utils, 'whileEach', require( './../while-each' ) ); 1743 1744 /** 1745 * @name whileEachRight 1746 * @memberof utils 1747 * @readonly 1748 * @type {Function} 1749 * @see {@link module:@stdlib/utils/while-each-right} 1750 */ 1751 setReadOnly( utils, 'whileEachRight', require( './../while-each-right' ) ); 1752 1753 /** 1754 * @name writableProperties 1755 * @memberof utils 1756 * @readonly 1757 * @type {Function} 1758 * @see {@link module:@stdlib/utils/writable-properties} 1759 */ 1760 setReadOnly( utils, 'writableProperties', require( './../writable-properties' ) ); 1761 1762 /** 1763 * @name writablePropertiesIn 1764 * @memberof utils 1765 * @readonly 1766 * @type {Function} 1767 * @see {@link module:@stdlib/utils/writable-properties-in} 1768 */ 1769 setReadOnly( utils, 'writablePropertiesIn', require( './../writable-properties-in' ) ); 1770 1771 /** 1772 * @name writablePropertyNames 1773 * @memberof utils 1774 * @readonly 1775 * @type {Function} 1776 * @see {@link module:@stdlib/utils/writable-property-names} 1777 */ 1778 setReadOnly( utils, 'writablePropertyNames', require( './../writable-property-names' ) ); 1779 1780 /** 1781 * @name writablePropertyNamesIn 1782 * @memberof utils 1783 * @readonly 1784 * @type {Function} 1785 * @see {@link module:@stdlib/utils/writable-property-names-in} 1786 */ 1787 setReadOnly( utils, 'writablePropertyNamesIn', require( './../writable-property-names-in' ) ); 1788 1789 /** 1790 * @name writablePropertySymbols 1791 * @memberof utils 1792 * @readonly 1793 * @type {Function} 1794 * @see {@link module:@stdlib/utils/writable-property-symbols} 1795 */ 1796 setReadOnly( utils, 'writablePropertySymbols', require( './../writable-property-symbols' ) ); 1797 1798 /** 1799 * @name writablePropertySymbolsIn 1800 * @memberof utils 1801 * @readonly 1802 * @type {Function} 1803 * @see {@link module:@stdlib/utils/writable-property-symbols-in} 1804 */ 1805 setReadOnly( utils, 'writablePropertySymbolsIn', require( './../writable-property-symbols-in' ) ); 1806 1807 /** 1808 * @name zip 1809 * @memberof utils 1810 * @readonly 1811 * @type {Function} 1812 * @see {@link module:@stdlib/utils/zip} 1813 */ 1814 setReadOnly( utils, 'zip', require( './../zip' ) ); 1815 1816 1817 // EXPORTS // 1818 1819 module.exports = utils;