").addClass(errClass).css("position", "absolute")
356 | .css("top", el.offsetTop)
357 | .css("left", el.offsetLeft)
358 | // setting width can push out the page size, forcing otherwise
359 | // unnecessary scrollbars to appear and making it impossible for
360 | // the element to shrink; so use max-width instead
361 | .css("maxWidth", el.offsetWidth)
362 | .css("height", el.offsetHeight);
363 | errorDiv.text(err.message);
364 | $el.after(errorDiv);
365 |
366 | // Really dumb way to keep the size/position of the error in sync with
367 | // the parent element as the window is resized or whatever.
368 | var intId = setInterval(function() {
369 | if (!errorDiv[0].parentElement) {
370 | clearInterval(intId);
371 | return;
372 | }
373 | errorDiv
374 | .css("top", el.offsetTop)
375 | .css("left", el.offsetLeft)
376 | .css("maxWidth", el.offsetWidth)
377 | .css("height", el.offsetHeight);
378 | }, 500);
379 | }
380 | }
381 | },
382 | clearError: function(el) {
383 | var $el = $(el);
384 | var display = $el.data("restore-display-mode");
385 | $el.data("restore-display-mode", null);
386 |
387 | if (display === "inline" || display === "inline-block") {
388 | if (display)
389 | $el.css("display", display);
390 | $(el.nextSibling).filter(".htmlwidgets-error").remove();
391 | } else if (display === "block"){
392 | $el.css("visibility", "inherit");
393 | $(el.nextSibling).filter(".htmlwidgets-error").remove();
394 | }
395 | },
396 | sizing: {}
397 | };
398 |
399 | // Called by widget bindings to register a new type of widget. The definition
400 | // object can contain the following properties:
401 | // - name (required) - A string indicating the binding name, which will be
402 | // used by default as the CSS classname to look for.
403 | // - initialize (optional) - A function(el) that will be called once per
404 | // widget element; if a value is returned, it will be passed as the third
405 | // value to renderValue.
406 | // - renderValue (required) - A function(el, data, initValue) that will be
407 | // called with data. Static contexts will cause this to be called once per
408 | // element; Shiny apps will cause this to be called multiple times per
409 | // element, as the data changes.
410 | window.HTMLWidgets.widget = function(definition) {
411 | if (!definition.name) {
412 | throw new Error("Widget must have a name");
413 | }
414 | if (!definition.type) {
415 | throw new Error("Widget must have a type");
416 | }
417 | // Currently we only support output widgets
418 | if (definition.type !== "output") {
419 | throw new Error("Unrecognized widget type '" + definition.type + "'");
420 | }
421 | // TODO: Verify that .name is a valid CSS classname
422 |
423 | // Support new-style instance-bound definitions. Old-style class-bound
424 | // definitions have one widget "object" per widget per type/class of
425 | // widget; the renderValue and resize methods on such widget objects
426 | // take el and instance arguments, because the widget object can't
427 | // store them. New-style instance-bound definitions have one widget
428 | // object per widget instance; the definition that's passed in doesn't
429 | // provide renderValue or resize methods at all, just the single method
430 | // factory(el, width, height)
431 | // which returns an object that has renderValue(x) and resize(w, h).
432 | // This enables a far more natural programming style for the widget
433 | // author, who can store per-instance state using either OO-style
434 | // instance fields or functional-style closure variables (I guess this
435 | // is in contrast to what can only be called C-style pseudo-OO which is
436 | // what we required before).
437 | if (definition.factory) {
438 | definition = createLegacyDefinitionAdapter(definition);
439 | }
440 |
441 | if (!definition.renderValue) {
442 | throw new Error("Widget must have a renderValue function");
443 | }
444 |
445 | // For static rendering (non-Shiny), use a simple widget registration
446 | // scheme. We also use this scheme for Shiny apps/documents that also
447 | // contain static widgets.
448 | window.HTMLWidgets.widgets = window.HTMLWidgets.widgets || [];
449 | // Merge defaults into the definition; don't mutate the original definition.
450 | var staticBinding = extend({}, defaults, definition);
451 | overrideMethod(staticBinding, "find", function(superfunc) {
452 | return function(scope) {
453 | var results = superfunc(scope);
454 | // Filter out Shiny outputs, we only want the static kind
455 | return filterByClass(results, "html-widget-output", false);
456 | };
457 | });
458 | window.HTMLWidgets.widgets.push(staticBinding);
459 |
460 | if (shinyMode) {
461 | // Shiny is running. Register the definition with an output binding.
462 | // The definition itself will not be the output binding, instead
463 | // we will make an output binding object that delegates to the
464 | // definition. This is because we foolishly used the same method
465 | // name (renderValue) for htmlwidgets definition and Shiny bindings
466 | // but they actually have quite different semantics (the Shiny
467 | // bindings receive data that includes lots of metadata that it
468 | // strips off before calling htmlwidgets renderValue). We can't
469 | // just ignore the difference because in some widgets it's helpful
470 | // to call this.renderValue() from inside of resize(), and if
471 | // we're not delegating, then that call will go to the Shiny
472 | // version instead of the htmlwidgets version.
473 |
474 | // Merge defaults with definition, without mutating either.
475 | var bindingDef = extend({}, defaults, definition);
476 |
477 | // This object will be our actual Shiny binding.
478 | var shinyBinding = new Shiny.OutputBinding();
479 |
480 | // With a few exceptions, we'll want to simply use the bindingDef's
481 | // version of methods if they are available, otherwise fall back to
482 | // Shiny's defaults. NOTE: If Shiny's output bindings gain additional
483 | // methods in the future, and we want them to be overrideable by
484 | // HTMLWidget binding definitions, then we'll need to add them to this
485 | // list.
486 | delegateMethod(shinyBinding, bindingDef, "getId");
487 | delegateMethod(shinyBinding, bindingDef, "onValueChange");
488 | delegateMethod(shinyBinding, bindingDef, "onValueError");
489 | delegateMethod(shinyBinding, bindingDef, "renderError");
490 | delegateMethod(shinyBinding, bindingDef, "clearError");
491 | delegateMethod(shinyBinding, bindingDef, "showProgress");
492 |
493 | // The find, renderValue, and resize are handled differently, because we
494 | // want to actually decorate the behavior of the bindingDef methods.
495 |
496 | shinyBinding.find = function(scope) {
497 | var results = bindingDef.find(scope);
498 |
499 | // Only return elements that are Shiny outputs, not static ones
500 | var dynamicResults = results.filter(".html-widget-output");
501 |
502 | // It's possible that whatever caused Shiny to think there might be
503 | // new dynamic outputs, also caused there to be new static outputs.
504 | // Since there might be lots of different htmlwidgets bindings, we
505 | // schedule execution for later--no need to staticRender multiple
506 | // times.
507 | if (results.length !== dynamicResults.length)
508 | scheduleStaticRender();
509 |
510 | return dynamicResults;
511 | };
512 |
513 | // Wrap renderValue to handle initialization, which unfortunately isn't
514 | // supported natively by Shiny at the time of this writing.
515 |
516 | shinyBinding.renderValue = function(el, data) {
517 | Shiny.renderDependencies(data.deps);
518 | // Resolve strings marked as javascript literals to objects
519 | if (!(data.evals instanceof Array)) data.evals = [data.evals];
520 | for (var i = 0; data.evals && i < data.evals.length; i++) {
521 | window.HTMLWidgets.evaluateStringMember(data.x, data.evals[i]);
522 | }
523 | if (!bindingDef.renderOnNullValue) {
524 | if (data.x === null) {
525 | el.style.visibility = "hidden";
526 | return;
527 | } else {
528 | el.style.visibility = "inherit";
529 | }
530 | }
531 | if (!elementData(el, "initialized")) {
532 | initSizing(el);
533 |
534 | elementData(el, "initialized", true);
535 | if (bindingDef.initialize) {
536 | var result = bindingDef.initialize(el, el.offsetWidth,
537 | el.offsetHeight);
538 | elementData(el, "init_result", result);
539 | }
540 | }
541 | bindingDef.renderValue(el, data.x, elementData(el, "init_result"));
542 | evalAndRun(data.jsHooks.render, elementData(el, "init_result"), [el, data.x]);
543 | };
544 |
545 | // Only override resize if bindingDef implements it
546 | if (bindingDef.resize) {
547 | shinyBinding.resize = function(el, width, height) {
548 | // Shiny can call resize before initialize/renderValue have been
549 | // called, which doesn't make sense for widgets.
550 | if (elementData(el, "initialized")) {
551 | bindingDef.resize(el, width, height, elementData(el, "init_result"));
552 | }
553 | };
554 | }
555 |
556 | Shiny.outputBindings.register(shinyBinding, bindingDef.name);
557 | }
558 | };
559 |
560 | var scheduleStaticRenderTimerId = null;
561 | function scheduleStaticRender() {
562 | if (!scheduleStaticRenderTimerId) {
563 | scheduleStaticRenderTimerId = setTimeout(function() {
564 | scheduleStaticRenderTimerId = null;
565 | window.HTMLWidgets.staticRender();
566 | }, 1);
567 | }
568 | }
569 |
570 | // Render static widgets after the document finishes loading
571 | // Statically render all elements that are of this widget's class
572 | window.HTMLWidgets.staticRender = function() {
573 | var bindings = window.HTMLWidgets.widgets || [];
574 | forEach(bindings, function(binding) {
575 | var matches = binding.find(document.documentElement);
576 | forEach(matches, function(el) {
577 | var sizeObj = initSizing(el, binding);
578 |
579 | if (hasClass(el, "html-widget-static-bound"))
580 | return;
581 | el.className = el.className + " html-widget-static-bound";
582 |
583 | var initResult;
584 | if (binding.initialize) {
585 | initResult = binding.initialize(el,
586 | sizeObj ? sizeObj.getWidth() : el.offsetWidth,
587 | sizeObj ? sizeObj.getHeight() : el.offsetHeight
588 | );
589 | elementData(el, "init_result", initResult);
590 | }
591 |
592 | if (binding.resize) {
593 | var lastSize = {
594 | w: sizeObj ? sizeObj.getWidth() : el.offsetWidth,
595 | h: sizeObj ? sizeObj.getHeight() : el.offsetHeight
596 | };
597 | var resizeHandler = function(e) {
598 | var size = {
599 | w: sizeObj ? sizeObj.getWidth() : el.offsetWidth,
600 | h: sizeObj ? sizeObj.getHeight() : el.offsetHeight
601 | };
602 | if (size.w === 0 && size.h === 0)
603 | return;
604 | if (size.w === lastSize.w && size.h === lastSize.h)
605 | return;
606 | lastSize = size;
607 | binding.resize(el, size.w, size.h, initResult);
608 | };
609 |
610 | on(window, "resize", resizeHandler);
611 |
612 | // This is needed for cases where we're running in a Shiny
613 | // app, but the widget itself is not a Shiny output, but
614 | // rather a simple static widget. One example of this is
615 | // an rmarkdown document that has runtime:shiny and widget
616 | // that isn't in a render function. Shiny only knows to
617 | // call resize handlers for Shiny outputs, not for static
618 | // widgets, so we do it ourselves.
619 | if (window.jQuery) {
620 | window.jQuery(document).on(
621 | "shown.htmlwidgets shown.bs.tab.htmlwidgets shown.bs.collapse.htmlwidgets",
622 | resizeHandler
623 | );
624 | window.jQuery(document).on(
625 | "hidden.htmlwidgets hidden.bs.tab.htmlwidgets hidden.bs.collapse.htmlwidgets",
626 | resizeHandler
627 | );
628 | }
629 |
630 | // This is needed for the specific case of ioslides, which
631 | // flips slides between display:none and display:block.
632 | // Ideally we would not have to have ioslide-specific code
633 | // here, but rather have ioslides raise a generic event,
634 | // but the rmarkdown package just went to CRAN so the
635 | // window to getting that fixed may be long.
636 | if (window.addEventListener) {
637 | // It's OK to limit this to window.addEventListener
638 | // browsers because ioslides itself only supports
639 | // such browsers.
640 | on(document, "slideenter", resizeHandler);
641 | on(document, "slideleave", resizeHandler);
642 | }
643 | }
644 |
645 | var scriptData = document.querySelector("script[data-for='" + el.id + "'][type='application/json']");
646 | if (scriptData) {
647 | var data = JSON.parse(scriptData.textContent || scriptData.text);
648 | // Resolve strings marked as javascript literals to objects
649 | if (!(data.evals instanceof Array)) data.evals = [data.evals];
650 | for (var k = 0; data.evals && k < data.evals.length; k++) {
651 | window.HTMLWidgets.evaluateStringMember(data.x, data.evals[k]);
652 | }
653 | binding.renderValue(el, data.x, initResult);
654 | evalAndRun(data.jsHooks.render, initResult, [el, data.x]);
655 | }
656 | });
657 | });
658 |
659 | invokePostRenderHandlers();
660 | }
661 |
662 |
663 | function has_jQuery3() {
664 | if (!window.jQuery) {
665 | return false;
666 | }
667 | var $version = window.jQuery.fn.jquery;
668 | var $major_version = parseInt($version.split(".")[0]);
669 | return $major_version >= 3;
670 | }
671 |
672 | /*
673 | / Shiny 1.4 bumped jQuery from 1.x to 3.x which means jQuery's
674 | / on-ready handler (i.e., $(fn)) is now asyncronous (i.e., it now
675 | / really means $(setTimeout(fn)).
676 | / https://jquery.com/upgrade-guide/3.0/#breaking-change-document-ready-handlers-are-now-asynchronous
677 | /
678 | / Since Shiny uses $() to schedule initShiny, shiny>=1.4 calls initShiny
679 | / one tick later than it did before, which means staticRender() is
680 | / called renderValue() earlier than (advanced) widget authors might be expecting.
681 | / https://github.com/rstudio/shiny/issues/2630
682 | /
683 | / For a concrete example, leaflet has some methods (e.g., updateBounds)
684 | / which reference Shiny methods registered in initShiny (e.g., setInputValue).
685 | / Since leaflet is privy to this life-cycle, it knows to use setTimeout() to
686 | / delay execution of those methods (until Shiny methods are ready)
687 | / https://github.com/rstudio/leaflet/blob/18ec981/javascript/src/index.js#L266-L268
688 | /
689 | / Ideally widget authors wouldn't need to use this setTimeout() hack that
690 | / leaflet uses to call Shiny methods on a staticRender(). In the long run,
691 | / the logic initShiny should be broken up so that method registration happens
692 | / right away, but binding happens later.
693 | */
694 | function maybeStaticRenderLater() {
695 | if (shinyMode && has_jQuery3()) {
696 | window.jQuery(window.HTMLWidgets.staticRender);
697 | } else {
698 | window.HTMLWidgets.staticRender();
699 | }
700 | }
701 |
702 | if (document.addEventListener) {
703 | document.addEventListener("DOMContentLoaded", function() {
704 | document.removeEventListener("DOMContentLoaded", arguments.callee, false);
705 | maybeStaticRenderLater();
706 | }, false);
707 | } else if (document.attachEvent) {
708 | document.attachEvent("onreadystatechange", function() {
709 | if (document.readyState === "complete") {
710 | document.detachEvent("onreadystatechange", arguments.callee);
711 | maybeStaticRenderLater();
712 | }
713 | });
714 | }
715 |
716 |
717 | window.HTMLWidgets.getAttachmentUrl = function(depname, key) {
718 | // If no key, default to the first item
719 | if (typeof(key) === "undefined")
720 | key = 1;
721 |
722 | var link = document.getElementById(depname + "-" + key + "-attachment");
723 | if (!link) {
724 | throw new Error("Attachment " + depname + "/" + key + " not found in document");
725 | }
726 | return link.getAttribute("href");
727 | };
728 |
729 | window.HTMLWidgets.dataframeToD3 = function(df) {
730 | var names = [];
731 | var length;
732 | for (var name in df) {
733 | if (df.hasOwnProperty(name))
734 | names.push(name);
735 | if (typeof(df[name]) !== "object" || typeof(df[name].length) === "undefined") {
736 | throw new Error("All fields must be arrays");
737 | } else if (typeof(length) !== "undefined" && length !== df[name].length) {
738 | throw new Error("All fields must be arrays of the same length");
739 | }
740 | length = df[name].length;
741 | }
742 | var results = [];
743 | var item;
744 | for (var row = 0; row < length; row++) {
745 | item = {};
746 | for (var col = 0; col < names.length; col++) {
747 | item[names[col]] = df[names[col]][row];
748 | }
749 | results.push(item);
750 | }
751 | return results;
752 | };
753 |
754 | window.HTMLWidgets.transposeArray2D = function(array) {
755 | if (array.length === 0) return array;
756 | var newArray = array[0].map(function(col, i) {
757 | return array.map(function(row) {
758 | return row[i]
759 | })
760 | });
761 | return newArray;
762 | };
763 | // Split value at splitChar, but allow splitChar to be escaped
764 | // using escapeChar. Any other characters escaped by escapeChar
765 | // will be included as usual (including escapeChar itself).
766 | function splitWithEscape(value, splitChar, escapeChar) {
767 | var results = [];
768 | var escapeMode = false;
769 | var currentResult = "";
770 | for (var pos = 0; pos < value.length; pos++) {
771 | if (!escapeMode) {
772 | if (value[pos] === splitChar) {
773 | results.push(currentResult);
774 | currentResult = "";
775 | } else if (value[pos] === escapeChar) {
776 | escapeMode = true;
777 | } else {
778 | currentResult += value[pos];
779 | }
780 | } else {
781 | currentResult += value[pos];
782 | escapeMode = false;
783 | }
784 | }
785 | if (currentResult !== "") {
786 | results.push(currentResult);
787 | }
788 | return results;
789 | }
790 | // Function authored by Yihui/JJ Allaire
791 | window.HTMLWidgets.evaluateStringMember = function(o, member) {
792 | var parts = splitWithEscape(member, '.', '\\');
793 | for (var i = 0, l = parts.length; i < l; i++) {
794 | var part = parts[i];
795 | // part may be a character or 'numeric' member name
796 | if (o !== null && typeof o === "object" && part in o) {
797 | if (i == (l - 1)) { // if we are at the end of the line then evalulate
798 | if (typeof o[part] === "string")
799 | o[part] = tryEval(o[part]);
800 | } else { // otherwise continue to next embedded object
801 | o = o[part];
802 | }
803 | }
804 | }
805 | };
806 |
807 | // Retrieve the HTMLWidget instance (i.e. the return value of an
808 | // HTMLWidget binding's initialize() or factory() function)
809 | // associated with an element, or null if none.
810 | window.HTMLWidgets.getInstance = function(el) {
811 | return elementData(el, "init_result");
812 | };
813 |
814 | // Finds the first element in the scope that matches the selector,
815 | // and returns the HTMLWidget instance (i.e. the return value of
816 | // an HTMLWidget binding's initialize() or factory() function)
817 | // associated with that element, if any. If no element matches the
818 | // selector, or the first matching element has no HTMLWidget
819 | // instance associated with it, then null is returned.
820 | //
821 | // The scope argument is optional, and defaults to window.document.
822 | window.HTMLWidgets.find = function(scope, selector) {
823 | if (arguments.length == 1) {
824 | selector = scope;
825 | scope = document;
826 | }
827 |
828 | var el = scope.querySelector(selector);
829 | if (el === null) {
830 | return null;
831 | } else {
832 | return window.HTMLWidgets.getInstance(el);
833 | }
834 | };
835 |
836 | // Finds all elements in the scope that match the selector, and
837 | // returns the HTMLWidget instances (i.e. the return values of
838 | // an HTMLWidget binding's initialize() or factory() function)
839 | // associated with the elements, in an array. If elements that
840 | // match the selector don't have an associated HTMLWidget
841 | // instance, the returned array will contain nulls.
842 | //
843 | // The scope argument is optional, and defaults to window.document.
844 | window.HTMLWidgets.findAll = function(scope, selector) {
845 | if (arguments.length == 1) {
846 | selector = scope;
847 | scope = document;
848 | }
849 |
850 | var nodes = scope.querySelectorAll(selector);
851 | var results = [];
852 | for (var i = 0; i < nodes.length; i++) {
853 | results.push(window.HTMLWidgets.getInstance(nodes[i]));
854 | }
855 | return results;
856 | };
857 |
858 | var postRenderHandlers = [];
859 | function invokePostRenderHandlers() {
860 | while (postRenderHandlers.length) {
861 | var handler = postRenderHandlers.shift();
862 | if (handler) {
863 | handler();
864 | }
865 | }
866 | }
867 |
868 | // Register the given callback function to be invoked after the
869 | // next time static widgets are rendered.
870 | window.HTMLWidgets.addPostRenderHandler = function(callback) {
871 | postRenderHandlers.push(callback);
872 | };
873 |
874 | // Takes a new-style instance-bound definition, and returns an
875 | // old-style class-bound definition. This saves us from having
876 | // to rewrite all the logic in this file to accomodate both
877 | // types of definitions.
878 | function createLegacyDefinitionAdapter(defn) {
879 | var result = {
880 | name: defn.name,
881 | type: defn.type,
882 | initialize: function(el, width, height) {
883 | return defn.factory(el, width, height);
884 | },
885 | renderValue: function(el, x, instance) {
886 | return instance.renderValue(x);
887 | },
888 | resize: function(el, width, height, instance) {
889 | return instance.resize(width, height);
890 | }
891 | };
892 |
893 | if (defn.find)
894 | result.find = defn.find;
895 | if (defn.renderError)
896 | result.renderError = defn.renderError;
897 | if (defn.clearError)
898 | result.clearError = defn.clearError;
899 |
900 | return result;
901 | }
902 | })();
903 |
904 |
--------------------------------------------------------------------------------
/result/Subburst_Chart_files/jquery-3.5.1/jquery-AUTHORS.txt:
--------------------------------------------------------------------------------
1 | Authors ordered by first contribution.
2 |
3 | John Resig
4 | Gilles van den Hoven
5 | Michael Geary
6 | Stefan Petre
7 | Yehuda Katz
8 | Corey Jewett
9 | Klaus Hartl
10 | Franck Marcia
11 | Jörn Zaefferer
12 | Paul Bakaus
13 | Brandon Aaron
14 | Mike Alsup
15 | Dave Methvin
16 | Ed Engelhardt
17 | Sean Catchpole
18 | Paul Mclanahan
19 | David Serduke
20 | Richard D. Worth
21 | Scott González
22 | Ariel Flesler
23 | Cheah Chu Yeow
24 | Andrew Chalkley
25 | Fabio Buffoni
26 | Stefan Bauckmeier
27 | Jon Evans
28 | TJ Holowaychuk
29 | Riccardo De Agostini
30 | Michael Bensoussan
31 | Louis-Rémi Babé
32 | Robert Katić
33 | Damian Janowski
34 | Anton Kovalyov
35 | Dušan B. Jovanovic
36 | Earle Castledine
37 | Rich Dougherty
38 | Kim Dalsgaard
39 | Andrea Giammarchi
40 | Fabian Jakobs
41 | Mark Gibson
42 | Karl Swedberg
43 | Justin Meyer
44 | Ben Alman
45 | James Padolsey
46 | David Petersen
47 | Batiste Bieler
48 | Jake Archibald
49 | Alexander Farkas
50 | Filipe Fortes
51 | Rick Waldron
52 | Neeraj Singh
53 | Paul Irish
54 | Iraê Carvalho
55 | Matt Curry
56 | Michael Monteleone
57 | Noah Sloan
58 | Tom Viner
59 | J. Ryan Stinnett
60 | Douglas Neiner
61 | Adam J. Sontag
62 | Heungsub Lee
63 | Dave Reed
64 | Carl Fürstenberg
65 | Jacob Wright
66 | Ralph Whitbeck
67 | unknown
68 | temp01
69 | Colin Snover
70 | Jared Grippe
71 | Ryan W Tenney
72 | Alex Sexton
73 | Pinhook
74 | Ron Otten
75 | Jephte Clain
76 | Anton Matzneller
77 | Dan Heberden
78 | Henri Wiechers
79 | Russell Holbrook
80 | Julian Aubourg
81 | Gianni Alessandro Chiappetta
82 | Scott Jehl
83 | James Burke
84 | Jonas Pfenniger
85 | Xavi Ramirez
86 | Sylvester Keil
87 | Brandon Sterne
88 | Mathias Bynens
89 | Lee Carpenter
90 | Timmy Willison <4timmywil@gmail.com>
91 | Corey Frang
92 | Digitalxero
93 | David Murdoch
94 | Josh Varner
95 | Charles McNulty
96 | Jordan Boesch
97 | Jess Thrysoee
98 | Michael Murray
99 | Alexis Abril
100 | Rob Morgan
101 | John Firebaugh
102 | Sam Bisbee
103 | Gilmore Davidson
104 | Brian Brennan
105 | Xavier Montillet
106 | Daniel Pihlstrom
107 | Sahab Yazdani
108 | avaly
109 | Scott Hughes
110 | Mike Sherov
111 | Greg Hazel
112 | Schalk Neethling
113 | Denis Knauf
114 | Timo Tijhof
115 | Steen Nielsen
116 | Anton Ryzhov
117 | Shi Chuan
118 | Matt Mueller
119 | Berker Peksag
120 | Toby Brain
121 | Justin
122 | Daniel Herman
123 | Oleg Gaidarenko
124 | Rock Hymas
125 | Richard Gibson
126 | Rafaël Blais Masson
127 | cmc3cn <59194618@qq.com>
128 | Joe Presbrey
129 | Sindre Sorhus
130 | Arne de Bree
131 | Vladislav Zarakovsky
132 | Andrew E Monat
133 | Oskari
134 | Joao Henrique de Andrade Bruni
135 | tsinha
136 | Dominik D. Geyer
137 | Matt Farmer
138 | Trey Hunner
139 | Jason Moon
140 | Jeffery To
141 | Kris Borchers
142 | Vladimir Zhuravlev
143 | Jacob Thornton
144 | Chad Killingsworth
145 | Vitya Muhachev
146 | Nowres Rafid
147 | David Benjamin
148 | Alan Plum
149 | Uri Gilad
150 | Chris Faulkner
151 | Marcel Greter
152 | Elijah Manor
153 | Daniel Chatfield
154 | Daniel Gálvez
155 | Nikita Govorov
156 | Wesley Walser
157 | Mike Pennisi
158 | Matthias Jäggli
159 | Devin Cooper
160 | Markus Staab
161 | Dave Riddle
162 | Callum Macrae
163 | Jonathan Sampson
164 | Benjamin Truyman
165 | Jay Merrifield
166 | James Huston
167 | Sai Lung Wong
168 | Erick Ruiz de Chávez
169 | David Bonner
170 | Allen J Schmidt Jr
171 | Akintayo Akinwunmi
172 | MORGAN
173 | Ismail Khair
174 | Carl Danley
175 | Mike Petrovich
176 | Greg Lavallee
177 | Tom H Fuertes
178 | Roland Eckl
179 | Yiming He
180 | David Fox
181 | Bennett Sorbo
182 | Paul Ramos
183 | Rod Vagg
184 | Sebastian Burkhard
185 | Zachary Adam Kaplan
186 | Adam Coulombe
187 | nanto_vi
188 | nanto
189 | Danil Somsikov
190 | Ryunosuke SATO
191 | Diego Tres
192 | Jean Boussier
193 | Andrew Plummer
194 | Mark Raddatz
195 | Pascal Borreli
196 | Isaac Z. Schlueter
197 | Karl Sieburg
198 | Nguyen Phuc Lam
199 | Dmitry Gusev
200 | Steven Benner
201 | Li Xudong
202 | Michał Gołębiowski-Owczarek
203 | Renato Oliveira dos Santos
204 | Frederic Junod
205 | Tom H Fuertes
206 | Mitch Foley
207 | ros3cin
208 | Kyle Robinson Young
209 | John Paul
210 | Jason Bedard
211 | Chris Talkington
212 | Eddie Monge
213 | Terry Jones
214 | Jason Merino
215 | Dan Burzo
216 | Jeremy Dunck
217 | Chris Price
218 | Guy Bedford
219 | njhamann
220 | Goare Mao
221 | Amey Sakhadeo
222 | Mike Sidorov
223 | Anthony Ryan
224 | Lihan Li
225 | George Kats
226 | Dongseok Paeng
227 | Ronny Springer
228 | Ilya Kantor
229 | Marian Sollmann
230 | Chris Antaki
231 | David Hong
232 | Jakob Stoeck
233 | Christopher Jones
234 | Forbes Lindesay
235 | S. Andrew Sheppard
236 | Leonardo Balter
237 | Rodrigo Rosenfeld Rosas
238 | Daniel Husar
239 | Philip Jägenstedt
240 | John Hoven
241 | Roman Reiß
242 | Benjy Cui
243 | Christian Kosmowski
244 | David Corbacho
245 | Liang Peng
246 | TJ VanToll
247 | Aurelio De Rosa
248 | Senya Pugach
249 | Dan Hart
250 | Nazar Mokrynskyi
251 | Benjamin Tan
252 | Amit Merchant
253 | Jason Bedard 
8 |
9 |
10 |
11 | 
120 |
121 |
122 |
123 | 
140 |
141 |