text:
<!doctype html>
<link rel="import" href="../polymer/polymer.html">
<link rel="import" href="../iron-icon/iron-icon.html">
<link rel="import" href="../paper-item/paper-icon-item.html">
<link rel="import" href="../paper-item/paper-item.html">
<link rel="import" href="../paper-item/paper-item-body.html">
<link rel="import" href="../paper-ripple/paper-ripple.html">
<link rel="import" href="../paper-input/paper-input-container.html">
<link rel="import" href="../iron-flex-layout/iron-flex-layout.html">
<link rel="import" href="../iron-flex-layout/iron-flex-layout-classes.html">
<link rel="import" href="../paper-styles/color.html">
<link rel="import" href="../paper-styles/default-theme.html">
<link rel="import" href="../paper-styles/shadow.html">
<link rel="import" href="../paper-styles/typography.html">
<link rel="import" href="paper-date-picker-edit-dialog.html">
<link rel="import" href="paper-time-picker-edit-dialog.html">
<link rel="import" href="paper-date-picker-behaviors.html">

<!--
`paper-datetime-picker-item` provides a Material Design item that shows a date and a time and opens a date/time picker dialog on tap.

### Example

```html
<paper-datetime-picker-item icon="icons:today" date="{{date}}" date-format="ll" time-format="LT"></paper-datetime-picker-item>
```

@demo demo/index.html
-->
<dom-module id="paper-datetime-picker-item">

	<template>
		<style>
			:host {
				@apply(--layout-horizontal);
			}

			.icon {
				color: var(--disabled-text-color);
			}

			.item[has-no-date] .text {
				color: var(--secondary-text-color);
			}

			paper-input {
				width: 80%;
				margin: 0 auto;

				font-size: 14px;
				font-family: "Roboto", sans-serif;
				font-weight: 400;
				line-height: 1.4;
				padding: 0 0 0 20px;

				--paper-input-container: {
					padding: 0;
				};

				--paper-input-container-input: {
					font-size: 14px;
					font-family: 'Roboto', sans-serif;
					font-weight: 400;
					opacity: 0.5;
				};
				--paper-input-container-focus-color: #2196f3;
				--paper-input-container-underline: {
					border-bottom: 1px solid rgba(0, 0, 0, 0.15) !important;
					border-top: none;
				};
				--paper-input-container-label-focus: {
					font-size: 14px;
					font-family: 'Roboto', sans-serif;
					font-weight: 400;
				};
				--paper-input-container-label: {
					opacity: 0.5;
				};
				--paper-input-container-label-floating: {
					font-size: 14px;
					color: #2196f3 !important;
					font-family: 'Roboto', sans-serif;
					font-weight: 500;
					opacity: 1;
					text-transform: capitalize;
				};
			}

			paper-icon-button {
				width: 34px;
				font-size: 14px;
				font-family: "Roboto", sans-serif;
				font-weight: 400;
				line-height: 1.4;
				margin-top: 15px;
			}

		</style>

		<paper-input readonly label="[[placeholder]]" on-tap="_editDate" has-no-date$="[[_hasNoDate]]"
					 value="[[_formattedDate]][[_formattedTime]]"></paper-input>
		<paper-icon-button icon="icons:clear" class="opacity-three" on-click="clear" on-tap="clear"></paper-icon-button>

	</template>

</dom-module>

<script>

    (function () {

        Polymer({
            is: 'paper-datetime-picker-item',
            properties: {
                /**
                 * Icon shown left of the date
                 */
                icon: String,

                _formattedDate: String,
                _formattedTime: {
                    type: String,
                    value: '',
                    computed: '_getFormattedTime(date, locale)'
                },
                _hasNoDate: {
                    type: Boolean,
                    value: true,
                    computed: '_computeHasNoDate(date)'
                }
            },

            behaviors: [
                Polymer.PaperDatePickerItemBehavior
            ],

            // Trigger calculation of _formattedDate also if date is undefined
            observers: [
                '_onChangedPlaceholder(placeholder, locale)',
                '_onChangedDate(date, locale)'
            ],

            clear: function (event) {

                if (this.callbackDeleteDateTime){
                    var self = this;

                    this.callbackDeleteDateTime(function () {
                        self.date = null;
                    });
				} else {
                    this.date = null;
                    this.fire('change', {value: null});
				}

            },

            rolledBackDate: function(){
                this.date = this.oldDate;
            },

            setDate: function (date) {
                this.date = date;
            },

            // Private methods
            _editDate: function () {

                if(!this.date){
                    this.date = null;
                }

                var dialog = document.createElement('paper-date-picker-edit-dialog');

                // Wait until dialog is created before the properties can be set
                // @see http://stackoverflow.com/a/31482376
                this.async(function () {

                    var self = this;
                    // Initialize dialog with the current date (default to today to avoid exception)

                    var nowDate = new Date();

                    if (this.date){
                        dialog.date = moment(this.date).toDate();
                    } else{

                        if (this.maxDate || this.minDate){

                            dialog.date = nowDate;

                            if (this.maxDate && (nowDate > moment(this.maxDate).hour("00").minute("00").second("01").toDate())){
                                dialog.date = moment(this.maxDate).toDate();
                            }

                            if (this.minDate && (nowDate < moment(this.minDate).hour("23").minute("59").second("59").toDate())){
                                dialog.date = moment(this.minDate).toDate();
                            }

                        } else {
                            dialog.date = nowDate;
                        }

                    }

                    dialog.maxDate = this.maxDate ? moment(this.maxDate).hour("23").minute("59").second("59").toDate() : null;
                    dialog.minDate = this.minDate ? moment(this.minDate).hour("00").minute("00").second("00").toDate() : null;

                    // Localize text
                    dialog.cancelButton = this.cancelButton;
                    dialog.okButton = this.okButton;

                    dialog.locale = this.locale;

                    // Capture date if the user saved the dialog
                    dialog.addEventListener('paper-date-picker-edit-dialog-save', function (e) {
                        var newDate = e.detail;
                        self.oldDate = this.date;

                        // If there is already a time picked, don't change it
                        // TODO: this piece is only necessary because of this issue with the date picker: https://github.com/bendavis78/paper-date-picker/issues/50
                        // Once issue is solved this method can be replaced by PaperDatePickerItemBehaviorImpl._edit
                        if (typeof this.date !== 'undefined' && this.date !== null) {
                            var hours = moment(this.date).format('HH');
                            var minutes = moment(this.date).format('mm');
                            newDate.setHours(hours, minutes);
                        } else if (this.defaultTime) {
//                             there is no old date, but we want to set the newly chosen one to the default time
                            var oldDate = new moment(this.defaultTime, 'HH:mm');
                            var hours = moment(oldDate).format('HH');
                            var minutes = moment(oldDate).format('mm');
                            newDate.setHours(hours, minutes);
                        }
                        this.date = newDate;

                        // Inform listener of 'change' events when the date was changed
                        this.fire('change', {value: this.date});
                        this._editTime();
                    }.bind(this));

                    dialog.addEventListener('paper-date-picker-cancel', function () {
                        self.rolledBackDate();
                        alert("wdfc");
                    });

                    dialog.open();
                }.bind(this));

                // Return dialog for unit testing
                return dialog;
            },
            _onChangedPlaceholder: function (placeholder, locale) {
                this._formattedDate = this._getFormattedDate(this.date, placeholder, locale);
            },
            _onChangedDate: function (date, locale) {
                this._formattedDate = this._getFormattedDate(date, this.placeholder, locale);
            },

            // Time related private methods
            _editTime: function () {
                return this._edit('paper-time-picker-edit-dialog');
            },
            _computeHasNoDate: function (date) {
                return typeof date === 'undefined' || date === null;
            },

            callbackChangeTime: function (dateTime) {
            },

            callbackDeleteDateTime:undefined
        });

    })();

</script>


text:
package ImageRepresentationModels.BoVW.Descriptors;

import java.awt.image.BufferedImage;
import java.io.*;
import java.util.ArrayList;
import java.util.List;

import net.sf.javaml.core.kdtree.KDTree;
import Clustering.KMeans.KDTreeImplementation;

import com.stromberglabs.jopensurf.*;

public class SurfFeatures implements Features {

	public void extractFeatures(BufferedImage image, BufferedWriter surfWriter) throws IOException {
		Surf surf= new Surf(image);
		List<SURFInterestPoint> points = surf.getFreeOrientedInterestPoints();

		 for ( int i =0 ; i< points.size();i++)
		{
		   float[] descriptor=	points.get(i).getDescriptor();
		   for ( int j =0 ; j< descriptor.length;j++)
			{
			   surfWriter.write(descriptor[j]+" ");
			}
		   surfWriter.write("\n");
		}

	}

	public void extractFeatures(BufferedImage image,List<double[]> centroids)  throws Exception {

		Surf surf= new Surf(image);
		List<SURFInterestPoint> points = surf.getFreeOrientedInterestPoints();
		for ( int i =0 ; i< points.size();i++)
		{
			float[] descriptor=	points.get(i).getDescriptor();
			double[] features = new double[64] ;
			for ( int j =0 ; j< descriptor.length;j++)
					features[j]=descriptor[j];
			centroids.add(features);
		}
	}

	@Override
	public double[] extract(BufferedImage image, KDTree tree, int clusterNum)
			throws Exception {

		List<double[]> centroids = new ArrayList<double[]>();
		Surf surf= new Surf(image);
		List<SURFInterestPoint> points = surf.getFreeOrientedInterestPoints();
		for ( int i =0 ; i< points.size();i++)
		{
			float[] descriptor=	points.get(i).getDescriptor();
			double[] features = new double[64] ;
			for ( int j =0 ; j< descriptor.length;j++)
			   features[j]=descriptor[j];

			centroids.add(features);
		}
		double[] imgVocVector = new double[clusterNum];//num of clusters
		for ( int i =0;i<imgVocVector.length;i++)
			imgVocVector[i]=0;

		//gia kathe ena feature trexe me ola ta centroids kai vres tin mikroteri apostasi
		for (int i = 0 ; i < centroids.size() ; i++) {
			int positionofMin= KDTreeImplementation.SearchTree(centroids.get(i),tree);
			imgVocVector[positionofMin]++;
		}
		return imgVocVector;
	}

	@Override
	public double[] extract(BufferedImage bimage) {
		return null;
	}

}

redpajama_set_name: RedPajamaGithub


text:
<?php

use Symfony\Component\Console\Application;

$console = new Application('PhpMetrics Dashboard Application', $app['version']);
$console->setDispatcher($app['dispatcher']);

$reportsCommand = new \PhpMetricsDashboard\Command\GenerateReportsCommand($app['file_system'], $app['git_wrapper'], $app['logger']);
$reportsCommand
    ->setPhpMetricsExecutablePath($app['phpmetrics.phar_path'])
    ->setProjectsConfigFile($app['projects.config_file'])
    ->setProjectsReportsFolder($app['projects.report_folder'])
    ->setProjectsSourceFolder($app['projects.source_folder'])
;

$console->add($reportsCommand);

return $console;


text:
<#
    DESCRIPTION:
        Check that a management network adapter exists.  This must always be present on a server and labelled correctly.

    REQUIRED-INPUTS:
        ManagementAdapterNames - "LIST" - Names or partial names of management network adapters

    DEFAULT-VALUES:
        ManagementAdapterNames = @('Management', 'MGMT', 'MGT')

    DEFAULT-STATE:
        Enabled

    RESULTS:
        PASS:
            Management network adapter found
        WARNING:
        FAIL:
            No management network adapter
        MANUAL:
        NA:

    APPLIES:
        All Servers

    REQUIRED-FUNCTIONS:
        None
#>

Function net-08-management-adapter
{
    $result        = newResult
    $result.server = $env:ComputerName
    $result.name   = $script:lang['Name']
    $result.check  = 'net-08-management-adapter'

    #... CHECK STARTS HERE ...#

    Try
    {
        [System.Text.StringBuilder]   $filter = "NetConnectionID='Null'"
        $script:chkValues['ManagementAdapterNames'] | ForEach-Object -Process { [void]$filter.Append(" OR NetConnectionID LIKE '%$_%'") }
        [System.Collections.ArrayList]$gCIMi  = @(Get-CimInstance -ClassName 'Win32_NetworkAdapter' -Filter $filter.ToString() -Property 'NetConnectionID')

        If ($gCIMi.Count -gt 0)
        {
            $result.result  =    $script:lang['Pass']
            $result.message =    $script:lang['p001']
            $result.data    = "$($gCIMi[0].NetConnectionID)"
        }
        Else
        {
            $result.result   = $script:lang['Fail']
            $result.message  = $script:lang['f001']
            $gCIMi | Sort-Object -Property 'NetConnectionID' | ForEach-Object -Process { $result.data += "$($_.NetConnectionID),#" }
        }
    }
    Catch
    {
        $result.result  = $script:lang['Error']
        $result.message = $script:lang['Script-Error']
        $result.data    = $_.Exception.Message
    }

    Return $result
}


text:
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Newtonsoft.Json;
using Storm.Binding.AndroidTarget.Configuration.Model;
using Storm.Binding.AndroidTarget.Helper;

namespace Storm.Binding.AndroidTarget.Configuration
{
	public class ConfigurationReader
	{
		public ConfigurationFile Read(string inputFile)
		{
			try
			{
				string content = File.ReadAllText(inputFile);

				ConfigurationFile result = JsonConvert.DeserializeObject<ConfigurationFile>(content);

				string relativePath = Path.GetDirectoryName(inputFile) ?? "";
				//Set classLocation & resourceLocation if they are not set into the json file
				result.ClassLocation = result.ClassLocation == null ? DefaultConfiguration.ClassLocation : PathHelper.Normalize(Path.Combine(relativePath, result.ClassLocation));
				result.ResourceLocation = result.ResourceLocation == null ? DefaultConfiguration.ResourceLocation : PathHelper.Normalize(Path.Combine(relativePath, result.ResourceLocation));
				if (string.IsNullOrWhiteSpace(result.GeneratedNamespace))
				{
					result.GeneratedNamespace = DefaultConfiguration.GeneratedNamespace;
				}
				if (string.IsNullOrWhiteSpace(result.DefaultTemplateSelector))
				{
					result.DefaultTemplateSelector = DefaultConfiguration.TemplateSelector;
				}
				if (string.IsNullOrWhiteSpace(result.DefaultTemplateSelectorField))
				{
					result.DefaultTemplateSelectorField = DefaultConfiguration.TemplateSelectorField;
				}
				if (string.IsNullOrWhiteSpace(result.DefaultAdapter))
				{
					result.DefaultAdapter = DefaultConfiguration.Adapter;
				}
				if (string.IsNullOrWhiteSpace(result.DefaultAdapterField))
				{
					result.DefaultAdapterField = DefaultConfiguration.AdapterField;
				}
				if (!result.CaseSensitivity.HasValue)
				{
					result.CaseSensitivity = DefaultConfiguration.CaseSensitivity;
				}

				//Add all default aliases if they have not been overriden
				Dictionary<string, string> aliases = result.Aliases.ToDictionary(x => x.Alias, x => x.FullClassName);
				foreach (AliasDescription alias in DefaultConfiguration.Aliases.Where(alias => !aliases.ContainsKey(alias.Alias)))
				{
					result.Aliases.Add(alias);
				}

				//Add all default namespaces
				foreach (string name in DefaultConfiguration.Namespaces.Where(name => !result.Namespaces.Contains(name)))
				{
					result.Namespaces.Add(name);
				}
				if (!result.Namespaces.Contains(result.GeneratedNamespace))
				{
					result.Namespaces.Add(result.GeneratedNamespace);
				}
				result.Namespaces.Sort();

				List<string> resourceFiles = result.GlobalResourceFiles.Select(x => PathHelper.Normalize(Path.Combine(relativePath, x))).ToList();
				result.GlobalResourceFiles.Clear();
				result.GlobalResourceFiles.AddRange(resourceFiles);

				//Process files to complete with full path
				foreach (FileBindingDescription fileBinding in result.FileDescriptions)
				{
					if (string.IsNullOrWhiteSpace(fileBinding.Activity.OutputFile))
					{
						// generate auto name for activity file
						fileBinding.Activity.OutputFile = string.Format("{0}.{1}.cs", fileBinding.Activity.NamespaceName, fileBinding.Activity.ClassName);
					}

					if (string.IsNullOrWhiteSpace(fileBinding.View.OutputFile))
					{
						// generate auto name for view file
						fileBinding.View.OutputFile = string.Format("{0}.axml", Path.GetFileNameWithoutExtension(fileBinding.View.InputFile));
					}

					// add full path as prefix to all file
					fileBinding.Activity.OutputFile = PathHelper.Normalize(Path.Combine(result.ClassLocation, fileBinding.Activity.OutputFile));
					fileBinding.View.OutputFile = PathHelper.Normalize(Path.Combine(result.ResourceLocation, fileBinding.View.OutputFile));
					fileBinding.View.InputFile = PathHelper.Normalize(Path.Combine(relativePath, fileBinding.View.InputFile));
				}

				return result;
			}
			catch (Exception)
			{
				BindingPreprocess.Logger.LogError("Cannot read input configuration file {0}", inputFile);
				throw;
			}
		}
	}
}


text:
<!DOCTYPE html>

  <title>SIUE Chemistry Department</title>
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta charset="UTF-8">
  <meta name="description" content="Chemistry at SIUE">
  <meta name="keywords" content="Chemistry,SIUE">
  <meta name="author" content="Team Porky">
  <link rel="stylesheet" href="lab.css">
  <BASE href="..">

1st Day of Lab Attendence Policy

        It has been, and will remain, the policy of the Department of Chemistry that a student may be removed from a class list and be replaced with persons on the wait list at the beginning of the first laboratory period.

At the beginning of the first lab period, the Department's lab manager organizes the students present in teams of two using waitlisted students if registered students are not present.

At this point, for safety concerns, anyone on the wait list who has not gained access to the lab is asked to leave.

The lab manager then assigns Lab kits to the students in courses that uses kits (note: General Chemistry no longer uses kits).  The Lab kits are checked and signed off by the student for completeness and safety.

The lab manager then initiates departmental, University, state, and federally mandated safety training.

Immediately following the training, students are must sign off that they have been made aware of the safety issues when taking a laboratory course.

The above tasks for the lab manager are exacerbated by the fact that the lab manager is attempting this task in multiple, simultaneously run lab sections.

In addition, after the described activities, most lab sections are then required to complete their first laboratory experiment in the time remaining. For the reasons described above, and the fact that the order of what needs to be accomplished and when are unalterable, the Department has the following policy on attendance of the first laboratory class:


text:
"""Tests for MaskedAutoregressiveFlow."""

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import numpy as np

from tensorflow.contrib.distributions.python.ops import test_util
from tensorflow.contrib.distributions.python.ops.bijectors.invert import Invert
from tensorflow.contrib.distributions.python.ops.bijectors.masked_autoregressive import _gen_mask
from tensorflow.contrib.distributions.python.ops.bijectors.masked_autoregressive import masked_autoregressive_default_template
from tensorflow.contrib.distributions.python.ops.bijectors.masked_autoregressive import MaskedAutoregressiveFlow
from tensorflow.python.framework import constant_op
from tensorflow.python.ops import array_ops
from tensorflow.python.ops import variables
from tensorflow.python.ops.distributions import normal as normal_lib
from tensorflow.python.ops.distributions import transformed_distribution as transformed_distribution_lib
from tensorflow.python.platform import test

class GenMaskTest(test.TestCase):

  def test346Exclusive(self):
    expected_mask = np.array(
        [[0, 0, 0, 0],
         [0, 0, 0, 0],
         [1, 0, 0, 0],
         [1, 0, 0, 0],
         [1, 1, 0, 0],
         [1, 1, 0, 0]])
    mask = _gen_mask(num_blocks=3, n_in=4, n_out=6, mask_type="exclusive")
    self.assertAllEqual(expected_mask, mask)

  def test346Inclusive(self):
    expected_mask = np.array(
        [[1, 0, 0, 0],
         [1, 0, 0, 0],
         [1, 1, 0, 0],
         [1, 1, 0, 0],
         [1, 1, 1, 0],
         [1, 1, 1, 0]])
    mask = _gen_mask(num_blocks=3, n_in=4, n_out=6, mask_type="inclusive")
    self.assertAllEqual(expected_mask, mask)

class MaskedAutoregressiveFlowTest(test_util.VectorDistributionTestHelpers,
                                   test.TestCase):

  @property
  def _autoregressive_flow_kwargs(self):
    return {
        "shift_and_log_scale_fn": masked_autoregressive_default_template(
            hidden_layers=[2], shift_only=False),
        "is_constant_jacobian": False,
    }

  def testBijector(self):
    x_ = np.arange(3 * 4 * 2).astype(np.float32).reshape(3, 4, 2)
    with self.cached_session() as sess:
      ma = MaskedAutoregressiveFlow(
          validate_args=True,
          **self._autoregressive_flow_kwargs)
      x = constant_op.constant(x_)
      forward_x = ma.forward(x)
      # Use identity to invalidate cache.
      inverse_y = ma.inverse(array_ops.identity(forward_x))
      fldj = ma.forward_log_det_jacobian(x, event_ndims=1)
      # Use identity to invalidate cache.
      ildj = ma.inverse_log_det_jacobian(
          array_ops.identity(forward_x), event_ndims=1)
      variables.global_variables_initializer().run()
      [
          forward_x_,
          inverse_y_,
          ildj_,
          fldj_,
      ] = sess.run([
          forward_x,
          inverse_y,
          ildj,
          fldj,
      ])
      self.assertEqual("masked_autoregressive_flow", ma.name)
      self.assertAllClose(forward_x_, forward_x_, rtol=1e-6, atol=0.)
      self.assertAllClose(x_, inverse_y_, rtol=1e-5, atol=0.)
      self.assertAllClose(ildj_, -fldj_, rtol=1e-6, atol=0.)

  def testMutuallyConsistent(self):
    dims = 4
    with self.cached_session() as sess:
      ma = MaskedAutoregressiveFlow(
          validate_args=True,
          **self._autoregressive_flow_kwargs)
      dist = transformed_distribution_lib.TransformedDistribution(
          distribution=normal_lib.Normal(loc=0., scale=1.),
          bijector=ma,
          event_shape=[dims],
          validate_args=True)
      self.run_test_sample_consistent_log_prob(
          sess_run_fn=sess.run,
          dist=dist,
          num_samples=int(1e5),
          radius=1.,
          center=0.,
          rtol=0.02)

  def testInvertMutuallyConsistent(self):
    dims = 4
    with self.cached_session() as sess:
      ma = Invert(MaskedAutoregressiveFlow(
          validate_args=True,
          **self._autoregressive_flow_kwargs))
      dist = transformed_distribution_lib.TransformedDistribution(
          distribution=normal_lib.Normal(loc=0., scale=1.),
          bijector=ma,
          event_shape=[dims],
          validate_args=True)
      self.run_test_sample_consistent_log_prob(
          sess_run_fn=sess.run,
          dist=dist,
          num_samples=int(1e5),
          radius=1.,
          center=0.,
          rtol=0.02)

class MaskedAutoregressiveFlowShiftOnlyTest(MaskedAutoregressiveFlowTest):

  @property
  def _autoregressive_flow_kwargs(self):
    return {
        "shift_and_log_scale_fn": masked_autoregressive_default_template(
            hidden_layers=[2], shift_only=True),
        "is_constant_jacobian": True,
    }

class MaskedAutoregressiveFlowUnrollLoopTest(MaskedAutoregressiveFlowTest):

  @property
  def _autoregressive_flow_kwargs(self):
    return {
        "shift_and_log_scale_fn": masked_autoregressive_default_template(
            hidden_layers=[2], shift_only=False),
        "is_constant_jacobian": False,
        "unroll_loop": True,
    }

if __name__ == "__main__":
  test.main()


text:
angular.
  module('userDetail').
  component('userDetail', {
    templateUrl:'user-detail/userdetail.html',
    controller: ['$scope','$http', '$routeParams', UserDetailController]
  });

  function UserDetailController($scope, $http, $routeParams){
    $scope.user = {};
    $http.get('http://mocker.egen.io/users/'+$routeParams.id).then(function(response) {
      $scope.user = response.data;
      console.log(response.data);
    });
    $scope.deleteUser = function(){
      $http.delete('http://mocker.egen.io/users/'+$routeParams.id).then(function(response){

      });
    }
  }


text:
// Copyright (c) 2016 AgileObjects Ltd
// Licensed under the MIT license. See LICENSE file in the ReadableExpressions directory for more information.

namespace LinkIt.ReadableExpressions.Extensions
{
    using System.Linq;
    using System.Linq.Expressions;

    /// <summary>
    /// Provides a set of static extension methods for Expression information.
    /// </summary>
    public static class PublicExpressionExtensions
    {
        /// <summary>
        /// Returns the Expression representing the subject of the given <paramref name="methodCall"/>.
        /// </summary>
        /// <param name="methodCall">
        /// The Expression representing the method call the subject of which should be retrieved.
        /// </param>
        /// <returns>
        /// The Expression representing the subject of the given <paramref name="methodCall"/>.
        /// </returns>
        public static Expression GetSubject(this MethodCallExpression methodCall)
        {
            return methodCall.Method.IsExtensionMethod()
                ? methodCall.Arguments.First() : methodCall.Object;
        }

        /// <summary>
        /// Gets the parent Expression for the given <paramref name="expression"/>.
        /// </summary>
        /// <param name="expression">The Expression for which to retrieve the parent.</param>
        /// <returns>The given <paramref name="expression"/>'s parent Expression.</returns>
        public static Expression GetParentOrNull(this Expression expression)
        {
            switch (expression.NodeType)
            {
                case ExpressionType.Call:
                    return ((MethodCallExpression)expression).GetSubject();

                case ExpressionType.MemberAccess:
                    return ((MemberExpression)expression).Expression;
            }

            return null;
        }
    }
}


text:
import { Client } from "../../client/modules/module_interface.ts";
import { CanvasSurface } from "../../client/surface/canvas_surface.ts";
import { Polygon } from "../../lib/math/polygon2d.ts";

export function load(wallGeometry: Polygon) {
  class GenlockTestClient extends Client {
    canvas!: CanvasRenderingContext2D;
    finishFadeOut() {
      if (this.surface) {
        this.surface.destroy();
      }
    }

    willBeShownSoon(container: HTMLElement) {
      const surface = new CanvasSurface(container, wallGeometry);
      this.surface = surface;
      this.canvas = surface.context;

      // Despite the background and text colors changing, the rest of the text
      // styling doesn't need to change on each frame.
      this.canvas.textAlign = "center";
      const fontHeight = Math.floor(this.surface.virtualRect.h / 10);
      this.canvas.font = fontHeight + "px Helvetica";
      this.canvas.textBaseline = "middle";
    }

    draw(time: number, delta: number) {
      const seconds = time / 1000;
      const nowIntSeconds = Math.floor(seconds);
      const lastIntSeconds = Math.floor(seconds - delta / 1000);
      if (nowIntSeconds != lastIntSeconds) {
        this.canvas.fillStyle = "white";
      } else {
        this.canvas.fillStyle = "black";
      }
      this.canvas.fillRect(
        0,
        0,
        this.surface!.virtualRect.w,
        this.surface!.virtualRect.h,
      );
    }
  }
  return { client: GenlockTestClient };
}


text:
(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('popper.js')) :
	typeof define === 'function' && define.amd ? define(['popper.js'], factory) :
	(global.tippy = factory(global.Popper));
}(this, (function (Popper) { 'use strict';

Popper = Popper && Popper.hasOwnProperty('default') ? Popper['default'] : Popper;

var isBrowser = typeof window !== 'undefined';

var browser = {};

var isLongerTimeoutBrowser = isBrowser && /UCBrowser|SAMSUNG/.test(navigator.userAgent);

if (isBrowser) {
  browser.supported = 'requestAnimationFrame' in window;
  browser.supportsTouch = 'ontouchstart' in window;
  browser.usingTouch = false;
  browser.dynamicInputDetection = true;
  browser.iOS = /iPhone|iPad|iPod/.test(navigator.platform) && !window.MSStream;
  browser.onUserInputChange = function () {};
  browser._eventListenersBound = false;
}

/**
 * Selector constants used for grabbing elements
 */
var selectors = {
  POPPER: '.tippy-popper',
  TOOLTIP: '.tippy-tooltip',
  CONTENT: '.tippy-content',
  BACKDROP: '.tippy-backdrop',
  ARROW: '.tippy-arrow',
  ROUND_ARROW: '.tippy-roundarrow',
  REFERENCE: '[data-tippy]'

  /**
   * The default options applied to each instance
   */
};var defaults = {
  placement: 'top',
  trigger: 'mouseenter focus',
  animation: 'shift-away',
  html: false,
  animateFill: true,
  arrow: false,
  delay: 0,
  duration: [350, 300],
  interactive: false,
  interactiveBorder: 2,
  theme: 'dark',
  size: 'regular',
  distance: 10,
  offset: 0,
  hideOnClick: true,
  multiple: false,
  followCursor: false,
  inertia: false,
  updateDuration: 350,
  sticky: false,
  appendTo: function appendTo() {
    return document.body;
  },
  zIndex: 9999,
  touchHold: false,
  performance: false,
  dynamicTitle: false,
  flip: true,
  flipBehavior: 'flip',
  arrowType: 'sharp',
  arrowTransform: '',
  maxWidth: '',
  popperOptions: {},
  createPopperInstanceOnInit: false,
  onShow: function onShow() {},
  onShown: function onShown() {},
  onHide: function onHide() {},
  onHidden: function onHidden() {}
};

/**
 * The keys of the defaults object for reducing down into a new object
 * Used in `getIndividualOptions()`
 */
var defaultsKeys = browser.supported && Object.keys(defaults);

/**
 * Determines if a value is an object literal
 * @param {*} value
 * @return {Boolean}
 */
function isObjectLiteral(value) {
  return Object.prototype.toString.call(value) === '[object Object]';
}

/**
 * Returns an array of elements based on the selector input
 * @param {String|Element|Element[]|NodeList|Object} selector
 * @return {Element[]}
 */
function getArrayOfElements(selector) {
  if (selector instanceof Element || isObjectLiteral(selector)) {
    return [selector];
  }

  if (selector instanceof NodeList) {
    return [].slice.call(selector);
  }

  if (Array.isArray(selector)) {
    return selector;
  }

  try {
    return [].slice.call(document.querySelectorAll(selector));
  } catch (_) {
    return [];
  }
}

/**
 * Returns the supported prefixed property - only `webkit` is needed, `moz`, `ms` and `o` are obsolete
 * @param {String} property
 * @return {String} - browser supported prefixed property
 */
function prefix(property) {
  var prefixes = [false, 'webkit'];
  var upperProp = property.charAt(0).toUpperCase() + property.slice(1);

  for (var i = 0; i < prefixes.length; i++) {
    var _prefix = prefixes[i];
    var prefixedProp = _prefix ? '' + _prefix + upperProp : property;
    if (typeof document.body.style[prefixedProp] !== 'undefined') {
      return prefixedProp;
    }
  }

  return null;
}

/**
 * Creates a popper element then returns it
 * @param {Number} id - the popper id
 * @param {String} title - the tooltip's `title` attribute
 * @param {Object} options - individual options
 * @return {Element} - the popper element
 */
function createPopperElement(id, title, options) {
  var placement = options.placement,
      distance = options.distance,
      arrow = options.arrow,
      arrowType = options.arrowType,
      arrowTransform = options.arrowTransform,
      animateFill = options.animateFill,
      inertia = options.inertia,
      animation = options.animation,
      size = options.size,
      theme = options.theme,
      html = options.html,
      zIndex = options.zIndex,
      interactive = options.interactive,
      maxWidth = options.maxWidth;

  var popper = document.createElement('div');
  popper.setAttribute('class', 'tippy-popper');
  popper.setAttribute('role', 'tooltip');
  popper.setAttribute('id', 'tippy-' + id);
  popper.style.zIndex = zIndex;
  popper.style.maxWidth = maxWidth;

  var tooltip = document.createElement('div');
  tooltip.setAttribute('class', 'tippy-tooltip');
  tooltip.setAttribute('data-size', size);
  tooltip.setAttribute('data-animation', animation);
  tooltip.setAttribute('data-state', 'hidden');

  theme.split(' ').forEach(function (t) {
    tooltip.classList.add(t + '-theme');
  });

  if (arrow) {
    var _arrow = document.createElement('div');
    _arrow.style[prefix('transform')] = arrowTransform;

    if (arrowType === 'round') {
      _arrow.classList.add('tippy-roundarrow');
      _arrow.innerHTML = '\n      <svg width="100%" height="100%" viewBox="0 0 64 20" xml:space="preserve" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:1.41421;">\n        <g transform="matrix(1.04009,0,0,1.45139,-1.26297,-65.9145)">\n          <path d="M1.214,59.185C1.214,59.185 12.868,59.992 21.5,51.55C29.887,43.347 33.898,43.308 42.5,51.55C51.352,60.031 62.747,59.185 62.747,59.185L1.214,59.185Z"/>\n        </g>\n      </svg>';
    } else {
      _arrow.classList.add('tippy-arrow');
    }

    tooltip.appendChild(_arrow);
  }

  if (animateFill) {
    // Create animateFill circle element for animation
    tooltip.setAttribute('data-animatefill', '');
    var circle = document.createElement('div');
    circle.setAttribute('data-state', 'hidden');
    circle.classList.add('tippy-backdrop');
    tooltip.appendChild(circle);
  }

  if (inertia) {
    // Change transition timing function cubic bezier
    tooltip.setAttribute('data-inertia', '');
  }

  if (interactive) {
    tooltip.setAttribute('data-interactive', '');
  }

  var content = document.createElement('div');
  content.setAttribute('class', 'tippy-content');

  if (html) {
    var templateId = void 0;

    if (html instanceof Element) {
      content.appendChild(html);
      templateId = '#' + html.id || 'tippy-html-template';
    } else {
      content.innerHTML = document.querySelector(html).innerHTML;
      templateId = html;
    }

    popper.setAttribute('data-html', '');
    interactive && popper.setAttribute('tabindex', '-1');
    tooltip.setAttribute('data-template-id', templateId);
  } else {
    content.innerHTML = title;
  }

  tooltip.appendChild(content);
  popper.appendChild(tooltip);

  return popper;
}

/**
 * Creates a trigger by adding the necessary event listeners to the reference element
 * @param {String} eventType - the custom event specified in the `trigger` setting
 * @param {Element} reference
 * @param {Object} handlers - the handlers for each event
 * @param {Boolean} touchHold
 * @return {Array} - array of listener objects
 */
function createTrigger(eventType, reference, handlers, touchHold) {
  var listeners = [];

  if (eventType === 'manual') return listeners;

  // Show
  reference.addEventListener(eventType, handlers.handleTrigger);
  listeners.push({
    event: eventType,
    handler: handlers.handleTrigger
  });

  // Hide
  if (eventType === 'mouseenter') {
    if (browser.supportsTouch && touchHold) {
      reference.addEventListener('touchstart', handlers.handleTrigger);
      listeners.push({
        event: 'touchstart',
        handler: handlers.handleTrigger
      });
      reference.addEventListener('touchend', handlers.handleMouseleave);
      listeners.push({
        event: 'touchend',
        handler: handlers.handleMouseleave
      });
    }

    reference.addEventListener('mouseleave', handlers.handleMouseleave);
    listeners.push({
      event: 'mouseleave',
      handler: handlers.handleMouseleave
    });
  }

  if (eventType === 'focus') {
    reference.addEventListener('blur', handlers.handleBlur);
    listeners.push({
      event: 'blur',
      handler: handlers.handleBlur
    });
  }

  return listeners;
}

var classCallCheck = function (instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
};

var createClass = function () {
  function defineProperties(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  return function (Constructor, protoProps, staticProps) {
    if (protoProps) defineProperties(Constructor.prototype, protoProps);
    if (staticProps) defineProperties(Constructor, staticProps);
    return Constructor;
  };
}();

var _extends = Object.assign || function (target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i];

    for (var key in source) {
      if (Object.prototype.hasOwnProperty.call(source, key)) {
        target[key] = source[key];
      }
    }
  }

  return target;
};

/**
 * Returns an object of settings to override global settings
 * @param {Element} reference
 * @param {Object} instanceOptions
 * @return {Object} - individual options
 */
function getIndividualOptions(reference, instanceOptions) {
  var options = defaultsKeys.reduce(function (acc, key) {
    var val = reference.getAttribute('data-tippy-' + key.toLowerCase()) || instanceOptions[key];

    // Convert strings to booleans
    if (val === 'false') val = false;
    if (val === 'true') val = true;

    // Convert number strings to true numbers
    if (isFinite(val) && !isNaN(parseFloat(val))) {
      val = parseFloat(val);
    }

    // Convert array strings to actual arrays
    if (typeof val === 'string' && val.trim().charAt(0) === '[') {
      val = JSON.parse(val);
    }

    acc[key] = val;

    return acc;
  }, {});

  return _extends({}, instanceOptions, options);
}

/**
 * Evaluates/modifies the options object for appropriate behavior
 * @param {Element|Object} reference
 * @param {Object} options
 * @return {Object} modified/evaluated options
 */
function evaluateOptions(reference, options) {
  // animateFill is disabled if an arrow is true
  if (options.arrow) {
    options.animateFill = false;
  }

  if (options.appendTo && typeof options.appendTo === 'function') {
    options.appendTo = options.appendTo();
  }

  if (typeof options.html === 'function') {
    options.html = options.html(reference);
  }

  return options;
}

/**
 * Returns inner elements of the popper element
 * @param {Element} popper
 * @return {Object}
 */
function getInnerElements(popper) {
  return {
    tooltip: popper.querySelector(selectors.TOOLTIP),
    backdrop: popper.querySelector(selectors.BACKDROP),
    content: popper.querySelector(selectors.CONTENT)
  };
}

/**
 * Removes the title from an element, setting `data-original-title`
 * appropriately
 * @param {Element} el
 */
function removeTitle(el) {
  var title = el.getAttribute('title');
  // Only set `data-original-title` attr if there is a title
  if (title) {
    el.setAttribute('data-original-title', title);
  }
  el.removeAttribute('title');
}

/**
 * Returns the core placement ('top', 'bottom', 'left', 'right') of a popper
 * @param {Element} popper
 * @return {String}
 */
function getPopperPlacement(popper) {
  return popper.getAttribute('x-placement').replace(/-.+/, '');
}

/**
 * Determines if the mouse's cursor is outside the interactive border
 * @param {MouseEvent} event
 * @param {Element} popper
 * @param {Object} options
 * @return {Boolean}
 */
function cursorIsOutsideInteractiveBorder(event, popper, options) {
  if (!popper.getAttribute('x-placement')) return true;

  var x = event.clientX,
      y = event.clientY;
  var interactiveBorder = options.interactiveBorder,
      distance = options.distance;

  var rect = popper.getBoundingClientRect();
  var placement = getPopperPlacement(popper);
  var borderWithDistance = interactiveBorder + distance;

  var exceeds = {
    top: rect.top - y > interactiveBorder,
    bottom: y - rect.bottom > interactiveBorder,
    left: rect.left - x > interactiveBorder,
    right: x - rect.right > interactiveBorder
  };

  switch (placement) {
    case 'top':
      exceeds.top = rect.top - y > borderWithDistance;
      break;
    case 'bottom':
      exceeds.bottom = y - rect.bottom > borderWithDistance;
      break;
    case 'left':
      exceeds.left = rect.left - x > borderWithDistance;
      break;
    case 'right':
      exceeds.right = x - rect.right > borderWithDistance;
      break;
  }

  return exceeds.top || exceeds.bottom || exceeds.left || exceeds.right;
}

/**
 * Transforms the `arrowTransform` numbers based on the placement axis
 * @param {String} type 'scale' or 'translate'
 * @param {Number[]} numbers
 * @param {Boolean} isVertical
 * @param {Boolean} isReverse
 * @return {String}
 */
function transformNumbersBasedOnPlacementAxis(type, numbers, isVertical, isReverse) {
  if (!numbers.length) return '';

  var transforms = {
    scale: function () {
      if (numbers.length === 1) {
        return '' + numbers[0];
      } else {
        return isVertical ? numbers[0] + ', ' + numbers[1] : numbers[1] + ', ' + numbers[0];
      }
    }(),
    translate: function () {
      if (numbers.length === 1) {
        return isReverse ? -numbers[0] + 'px' : numbers[0] + 'px';
      } else {
        if (isVertical) {
          return isReverse ? numbers[0] + 'px, ' + -numbers[1] + 'px' : numbers[0] + 'px, ' + numbers[1] + 'px';
        } else {
          return isReverse ? -numbers[1] + 'px, ' + numbers[0] + 'px' : numbers[1] + 'px, ' + numbers[0] + 'px';
        }
      }
    }()
  };

  return transforms[type];
}

/**
 * Transforms the `arrowTransform` x or y axis based on the placement axis
 * @param {String} axis 'X', 'Y', ''
 * @param {Boolean} isVertical
 * @return {String}
 */
function transformAxis(axis, isVertical) {
  if (!axis) return '';
  var map = {
    X: 'Y',
    Y: 'X'
  };
  return isVertical ? axis : map[axis];
}

/**
 * Computes and applies the necessary arrow transform
 * @param {Element} popper
 * @param {Element} arrow
 * @param {String} arrowTransform
 */
function computeArrowTransform(popper, arrow, arrowTransform) {
  var placement = getPopperPlacement(popper);
  var isVertical = placement === 'top' || placement === 'bottom';
  var isReverse = placement === 'right' || placement === 'bottom';

  var getAxis = function getAxis(re) {
    var match = arrowTransform.match(re);
    return match ? match[1] : '';
  };

  var getNumbers = function getNumbers(re) {
    var match = arrowTransform.match(re);
    return match ? match[1].split(',').map(parseFloat) : [];
  };

  var re = {
    translate: /translateX?Y?\(([^)]+)\)/,
    scale: /scaleX?Y?\(([^)]+)\)/
  };

  var matches = {
    translate: {
      axis: getAxis(/translate([XY])/),
      numbers: getNumbers(re.translate)
    },
    scale: {
      axis: getAxis(/scale([XY])/),
      numbers: getNumbers(re.scale)
    }
  };

  var computedTransform = arrowTransform.replace(re.translate, 'translate' + transformAxis(matches.translate.axis, isVertical) + '(' + transformNumbersBasedOnPlacementAxis('translate', matches.translate.numbers, isVertical, isReverse) + ')').replace(re.scale, 'scale' + transformAxis(matches.scale.axis, isVertical) + '(' + transformNumbersBasedOnPlacementAxis('scale', matches.scale.numbers, isVertical, isReverse) + ')');

  arrow.style[prefix('transform')] = computedTransform;
}

/**
 * Determines if an element is visible in the viewport
 * @param {Element} el
 * @return {Boolean}
 */
function elementIsInViewport(el) {
  var rect = el.getBoundingClientRect();

  return rect.top >= 0 && rect.left >= 0 && rect.bottom <= (window.innerHeight || document.documentElement.clientHeight) && rect.right <= (window.innerWidth || document.documentElement.clientWidth);
}

/**
 * Returns the distance taking into account the default distance due to
 * the transform: translate setting in CSS
 * @param {Number} distance
 * @return {String}
 */
function getOffsetDistanceInPx(distance) {
  return -(distance - defaults.distance) + 'px';
}

/**
 * Waits until next repaint to execute a fn
 * NOTE: UC Browser / Samsung Internet need a longer timeout
 * @param {Function} fn
 */
function defer(fn) {
  requestAnimationFrame(function () {
    setTimeout(fn, isLongerTimeoutBrowser ? 60 : 0);
  });
}

var matches = {};

if (isBrowser) {
  var e = Element.prototype;
  matches = e.matches || e.matchesSelector || e.webkitMatchesSelector || e.mozMatchesSelector || e.msMatchesSelector || function (s) {
    var matches = (this.document || this.ownerDocument).querySelectorAll(s);
    var i = matches.length;
    while (--i >= 0 && matches.item(i) !== this) {}
    return i > -1;
  };
}

var matches$1 = matches;

/**
 * Ponyfill to get the closest parent element
 * @param {Element} element - child of parent to be returned
 * @param {String} parentSelector - selector to match the parent if found
 * @return {Element}
 */
function closest(element, parentSelector) {
  var fn = Element.prototype.closest || function (selector) {
    var el = this;
    while (el) {
      if (matches$1.call(el, selector)) {
        return el;
      }
      el = el.parentElement;
    }
  };

  return fn.call(element, parentSelector);
}

/**
 * Returns duration taking into account the option being either a number or array
 * @param {Number} duration
 * @param {Number} index
 * @return {Number}
 */
function getDuration(duration, index) {
  return Array.isArray(duration) ? duration[index] : duration;
}

/**
 * Sets the visibility state of an element for transition to begin
 * @param {Element[]} els - array of elements
 * @param {String} type - 'visible' or 'hidden'
 */
function setVisibilityState(els, type) {
  els.forEach(function (el) {
    if (!el) return;
    el.setAttribute('data-state', type);
  });
}

/**
 * Ponyfill for Array.prototype.find
 * @param {Array} arr
 * @param {Function} fn
 * @return item in the array
 */

/**
 * Applies the transition duration to each element
 * @param {Element[]} els - Array of elements
 * @param {Number} duration
 */
function applyTransitionDuration(els, duration) {
  els.forEach(function (el) {
    if (!el) return;
    el.style[prefix('transitionDuration')] = duration + 'ms';
  });
}

var T = (function () {
  var key = {};
  var store = function store(data) {
    return function (k) {
      return k === key && data;
    };
  };

  var Tippy = function () {
    function Tippy(config) {
      classCallCheck(this, Tippy);

      for (var _key in config) {
        this[_key] = config[_key];
      }

      this.state = {
        destroyed: false,
        visible: false,
        enabled: true
      };

      this._ = store({
        mutationObservers: []
      });
    }

    /**
     * Enables the tooltip to allow it to show or hide
     * @memberof Tippy
     * @public
     */

    createClass(Tippy, [{
      key: 'enable',
      value: function enable() {
        this.state.enabled = true;
      }

      /**
       * Disables the tooltip from showing or hiding, but does not destroy it
       * @memberof Tippy
       * @public
       */

    }, {
      key: 'disable',
      value: function disable() {
        this.state.enabled = false;
      }

      /**
       * Shows the tooltip
       * @param {Number} duration in milliseconds
       * @memberof Tippy
       * @public
       */

    }, {
      key: 'show',
      value: function show(duration) {
        var _this = this;

        if (this.state.destroyed || !this.state.enabled) return;

        var popper = this.popper,
            reference = this.reference,
            options = this.options;

        var _getInnerElements = getInnerElements(popper),
            tooltip = _getInnerElements.tooltip,
            backdrop = _getInnerElements.backdrop,
            content = _getInnerElements.content;

        // Destroy tooltip if the reference element is no longer on the DOM

        if (!reference.refObj && !document.documentElement.contains(reference)) {
          this.destroy();
          return;
        }

        options.onShow.call(popper);

        duration = getDuration(duration !== undefined ? duration : options.duration, 0);

        // Prevent a transition when popper changes position
        applyTransitionDuration([popper, tooltip, backdrop], 0);

        _mount.call(this);

        popper.style.visibility = 'visible';
        this.state.visible = true;

        // Popper#update is async, requiring us to defer this code. Popper 2.0 will make it sync.
        defer(function () {
          // ~20ms can elapse before this defer callback is run, so the hide() method
          // may have been invoked -- check if the popper is still visible and cancel
          // this callback if not
          if (!_this.state.visible) return;

          if (!options.followCursor || browser.usingTouch) {
            _this.popperInstance.update();
            applyTransitionDuration([popper], options.updateDuration);
          }

          // Re-apply transition durations
          applyTransitionDuration([tooltip, backdrop, backdrop ? content : null], duration);

          if (backdrop) {
            getComputedStyle(backdrop)[prefix('transform')];
          }

          if (options.interactive) {
            reference.classList.add('tippy-active');
          }

          if (options.sticky) {
            _makeSticky.call(_this);
          }

          setVisibilityState([tooltip, backdrop], 'visible');

          _onTransitionEnd.call(_this, duration, function () {
            if (!options.updateDuration) {
              tooltip.classList.add('tippy-notransition');
            }

            if (options.interactive) {
              popper.focus();
            }

            options.onShown.call(popper);
          });
        });
      }

      /**
       * Hides the tooltip
       * @param {Number} duration in milliseconds
       * @memberof Tippy
       * @public
       */

    }, {
      key: 'hide',
      value: function hide(duration) {
        var _this2 = this;

        if (this.state.destroyed || !this.state.enabled) return;

        var popper = this.popper,
            reference = this.reference,
            options = this.options;

        var _getInnerElements2 = getInnerElements(popper),
            tooltip = _getInnerElements2.tooltip,
            backdrop = _getInnerElements2.backdrop,
            content = _getInnerElements2.content;

        options.onHide.call(popper);

        duration = getDuration(duration !== undefined ? duration : options.duration, 1);

        if (!options.updateDuration) {
          tooltip.classList.remove('tippy-notransition');
        }

        if (options.interactive) {
          reference.classList.remove('tippy-active');
        }

        popper.style.visibility = 'hidden';
        this.state.visible = false;

        applyTransitionDuration([tooltip, backdrop, backdrop ? content : null], duration);

        setVisibilityState([tooltip, backdrop], 'hidden');

        if (options.interactive && options.trigger.indexOf('click') > -1 && elementIsInViewport(reference)) {
          reference.focus();
        }

        /*
        * This call is deferred because sometimes when the tooltip is still transitioning in but hide()
        * is called before it finishes, the CSS transition won't reverse quickly enough, meaning
        * the CSS transition will finish 1-2 frames later, and onHidden() will run since the JS set it
        * more quickly. It should actually be onShown(). Seems to be something Chrome does, not Safari
        */
        defer(function () {
          _onTransitionEnd.call(_this2, duration, function () {
            if (_this2.state.visible || !options.appendTo.contains(popper)) return;

            if (!_this2._(key).isPreparingToShow) {
              document.removeEventListener('mousemove', _this2._(key).followCursorListener);
            }

            _this2.popperInstance.disableEventListeners();
            options.appendTo.removeChild(popper);
            options.onHidden.call(popper);
          });
        });
      }

      /**
       * Destroys the tooltip
       * @memberof Tippy
       * @public
       */

    }, {
      key: 'destroy',
      value: function destroy() {
        var _this3 = this;

        if (this.state.destroyed) return;

        // Ensure the popper is hidden
        if (this.state.visible) {
          this.hide(0);
        }

        this.listeners.forEach(function (listener) {
          _this3.reference.removeEventListener(listener.event, listener.handler);
        });

        // Restore title
        this.reference.setAttribute('title', this.reference.getAttribute('data-original-title'));

        delete this.reference._tippy;['data-original-title', 'data-tippy', 'aria-describedby'].forEach(function (attr) {
          _this3.reference.removeAttribute(attr);
        });

        if (this.popperInstance) {
          this.popperInstance.destroy();
        }

        this._(key).mutationObservers.forEach(function (observer) {
          observer.disconnect();
        });

        this.state.destroyed = true;
      }
    }]);
    return Tippy;
  }();

  /**
   * ------------------------------------------------------------------------
   * Private methods
   * ------------------------------------------------------------------------
   * Standalone functions to be called with the instance's `this` context to make
   * them truly private and not accessible on the prototype
   */

  /**
   * Method used by event listeners to invoke the show method, taking into account delays and
   * the `wait` option
   * @param {Event} event
   * @memberof Tippy
   * @private
   */

  function _enter(event) {
    var _this4 = this;

    _clearDelayTimeouts.call(this);

    if (this.state.visible) return;

    this._(key).isPreparingToShow = true;

    if (this.options.wait) {
      this.options.wait.call(this.popper, this.show.bind(this), event);
      return;
    }

    // If the tooltip has a delay, we need to be listening to the mousemove as soon as the trigger
    // event is fired so that it's in the correct position upon mount.
    if (this.options.followCursor && !browser.usingTouch) {
      if (!this._(key).followCursorListener) {
        _setFollowCursorListener.call(this);
      }
      document.addEventListener('mousemove', this._(key).followCursorListener);
    }

    var delay = Array.isArray(this.options.delay) ? this.options.delay[0] : this.options.delay;

    if (delay) {
      this._(key).showTimeout = setTimeout(function () {
        _this4.show();
      }, delay);
    } else {
      this.show();
    }
  }

  /**
   * Method used by event listeners to invoke the hide method, taking into account delays
   * @memberof Tippy
   * @private
   */
  function _leave() {
    var _this5 = this;

    _clearDelayTimeouts.call(this);

    if (!this.state.visible) return;

    this._(key).isPreparingToShow = false;

    var delay = Array.isArray(this.options.delay) ? this.options.delay[1] : this.options.delay;

    if (delay) {
      this._(key).hideTimeout = setTimeout(function () {
        if (!_this5.state.visible) return;
        _this5.hide();
      }, delay);
    } else {
      this.hide();
    }
  }

  /**
   * Returns relevant listeners for the instance
   * @return {Object} of listeners
   * @memberof Tippy
   * @private
   */
  function _getEventListeners() {
    var _this6 = this;

    var handleTrigger = function handleTrigger(event) {
      if (!_this6.state.enabled) return;

      var shouldStopEvent = browser.supportsTouch && browser.usingTouch && (event.type === 'mouseenter' || event.type === 'focus');

      if (shouldStopEvent && _this6.options.touchHold) return;

      _this6._(key).lastTriggerEvent = event;

      // Toggle show/hide when clicking click-triggered tooltips
      if (event.type === 'click' && _this6.options.hideOnClick !== 'persistent' && _this6.state.visible) {
        _leave.call(_this6);
      } else {
        _enter.call(_this6, event);
      }

      // iOS prevents click events from firing
      if (shouldStopEvent && browser.iOS && _this6.reference.click) {
        _this6.reference.click();
      }
    };

    var handleMouseleave = function handleMouseleave(event) {
      if (event.type === 'mouseleave' && browser.supportsTouch && browser.usingTouch && _this6.options.touchHold) return;

      if (_this6.options.interactive) {
        var hide = _leave.bind(_this6);

        // Temporarily handle mousemove to check if the mouse left somewhere other than the popper
        var handleMousemove = function handleMousemove(event) {
          var referenceCursorIsOver = closest(event.target, selectors.REFERENCE);
          var cursorIsOverPopper = closest(event.target, selectors.POPPER) === _this6.popper;
          var cursorIsOverReference = referenceCursorIsOver === _this6.reference;

          if (cursorIsOverPopper || cursorIsOverReference) return;

          if (cursorIsOutsideInteractiveBorder(event, _this6.popper, _this6.options)) {
            document.body.removeEventListener('mouseleave', hide);
            document.removeEventListener('mousemove', handleMousemove);

            _leave.call(_this6);
          }
        };
        document.body.addEventListener('mouseleave', hide);
        document.addEventListener('mousemove', handleMousemove);
        return;
      }

      _leave.call(_this6);
    };

    var handleBlur = function handleBlur(event) {
      if (!event.relatedTarget || browser.usingTouch) return;
      if (closest(event.relatedTarget, selectors.POPPER)) return;

      _leave.call(_this6);
    };

    return {
      handleTrigger: handleTrigger,
      handleMouseleave: handleMouseleave,
      handleBlur: handleBlur
    };
  }

  /**
   * Creates and returns a new popper instance
   * @return {Popper}
   * @memberof Tippy
   * @private
   */
  function _createPopperInstance() {
    var _this7 = this;

    var popper = this.popper,
        reference = this.reference,
        options = this.options;

    var _getInnerElements3 = getInnerElements(popper),
        tooltip = _getInnerElements3.tooltip;

    var popperOptions = options.popperOptions;

    var arrowSelector = options.arrowType === 'round' ? selectors.ROUND_ARROW : selectors.ARROW;
    var arrow = tooltip.querySelector(arrowSelector);

    var config = _extends({
      placement: options.placement
    }, popperOptions || {}, {
      modifiers: _extends({}, popperOptions ? popperOptions.modifiers : {}, {
        arrow: _extends({
          element: arrowSelector
        }, popperOptions && popperOptions.modifiers ? popperOptions.modifiers.arrow : {}),
        flip: _extends({
          enabled: options.flip,
          padding: options.distance + 5 /* 5px from viewport boundary */
          , behavior: options.flipBehavior
        }, popperOptions && popperOptions.modifiers ? popperOptions.modifiers.flip : {}),
        offset: _extends({
          offset: options.offset
        }, popperOptions && popperOptions.modifiers ? popperOptions.modifiers.offset : {})
      }),
      onCreate: function onCreate() {
        tooltip.style[getPopperPlacement(popper)] = getOffsetDistanceInPx(options.distance);

        if (arrow && options.arrowTransform) {
          computeArrowTransform(popper, arrow, options.arrowTransform);
        }
      },
      onUpdate: function onUpdate() {
        var styles = tooltip.style;
        styles.top = '';
        styles.bottom = '';
        styles.left = '';
        styles.right = '';
        styles[getPopperPlacement(popper)] = getOffsetDistanceInPx(options.distance);

        if (arrow && options.arrowTransform) {
          computeArrowTransform(popper, arrow, options.arrowTransform);
        }
      }
    });

    _addMutationObserver.call(this, {
      target: popper,
      callback: function callback() {
        var styles = popper.style;
        styles[prefix('transitionDuration')] = '0ms';
        _this7.popperInstance.update();
        defer(function () {
          styles[prefix('transitionDuration')] = options.updateDuration + 'ms';
        });
      },
      options: {
        childList: true,
        subtree: true,
        characterData: true
      }
    });

    return new Popper(reference, popper, config);
  }

  /**
   * Appends the popper element to the DOM
   * @memberof Tippy
   * @private
   */
  function _mount() {
    var _this8 = this;

    if (this.options.appendTo.contains(this.popper)) return;
    this.options.appendTo.appendChild(this.popper);

    if (!this.popperInstance) {
      this.popperInstance = _createPopperInstance.call(this);
    } else {
      this.popper.style[prefix('transform')] = null;
      this.popperInstance.update();

      if (!this.options.followCursor || browser.usingTouch) {
        this.popperInstance.enableEventListeners();
      }
    }

    // Set initial position near cursor
    if (this.options.followCursor && !browser.usingTouch) {
      this.popperInstance.disableEventListeners();
      defer(function () {
        _this8._(key).followCursorListener(_this8._(key).lastMouseMoveEvent || _this8._(key).lastTriggerEvent);
      });
    }
  }

  /**
   * Clears the show and hide delay timeouts
   * @memberof Tippy
   * @private
   */
  function _clearDelayTimeouts() {
    var _ref = this._(key),
        showTimeout = _ref.showTimeout,
        hideTimeout = _ref.hideTimeout;

    clearTimeout(showTimeout);
    clearTimeout(hideTimeout);
  }

  /**
   * Sets the mousemove event listener function for `followCursor` option
   * @memberof Tippy
   * @private
   */
  function _setFollowCursorListener() {
    var _this9 = this;

    this._(key).followCursorListener = function (event) {
      // Ignore if the tooltip was triggered by `focus`
      if (_this9._(key).lastTriggerEvent && _this9._(key).lastTriggerEvent.type === 'focus') return;

      _this9._(key).lastMouseMoveEvent = event;

      // Expensive operations, but their dimensions can change freely
      var pageWidth = document.documentElement.offsetWidth || document.body.offsetWidth;
      var halfPopperWidth = Math.round(_this9.popper.offsetWidth / 2);
      var halfPopperHeight = Math.round(_this9.popper.offsetHeight / 2);
      var offset = _this9.options.offset;
      var pageX = event.pageX,
          pageY = event.pageY;

      var PADDING = 5;

      // Obscure case: If the user scrolled to the element without moving
      // their mouse, it would be at the wrong position.
      if (_this9.reference.getBoundingClientRect) {
        var rect = _this9.reference.getBoundingClientRect();
        var oY = window.scrollY || document.documentElement.scrollTop;
        var oX = window.scrollX || document.documentElement.scrollLeft;
        if (_this9.state.visible && _this9._(key).isPreparingToShow && (pageX < rect.left + oX || pageX > rect.right + oX || pageY > rect.bottom + oY || pageY < rect.top + oY)) {
          return;
        }
      }

      var placement = _this9.options.placement.replace(/-.+/, '');
      if (_this9.popper.getAttribute('x-placement')) {
        placement = getPopperPlacement(_this9.popper);
      }

      var x = void 0,
          y = void 0;

      switch (placement) {
        case 'top':
          x = pageX - halfPopperWidth + offset;
          y = pageY - 2 * halfPopperHeight;
          break;
        case 'bottom':
          x = pageX - halfPopperWidth + offset;
          y = pageY + 10;
          break;
        case 'left':
          x = pageX - 2 * halfPopperWidth;
          y = pageY - halfPopperHeight + offset;
          break;
        case 'right':
          x = pageX + 5;
          y = pageY - halfPopperHeight + offset;
          break;
      }

      var isRightOverflowing = pageX + PADDING + halfPopperWidth + offset > pageWidth;
      var isLeftOverflowing = pageX - PADDING - halfPopperWidth + offset < 0;

      // Prevent left/right overflow
      if (placement === 'top' || placement === 'bottom') {
        if (isRightOverflowing) {
          x = pageWidth - PADDING - 2 * halfPopperWidth;
        }

        if (isLeftOverflowing) {
          x = PADDING;
        }
      }

      _this9.popper.style[prefix('transform')] = 'translate3d(' + x + 'px, ' + y + 'px, 0)';
    };
  }

  /**
   * Updates the popper's position on each animation frame
   * @memberof Tippy
   * @private
   */
  function _makeSticky() {
    var _this10 = this;

    var applyTransitionDuration$$1 = function applyTransitionDuration$$1() {
      _this10.popper.style[prefix('transitionDuration')] = _this10.options.updateDuration + 'ms';
    };

    var removeTransitionDuration = function removeTransitionDuration() {
      _this10.popper.style[prefix('transitionDuration')] = '';
    };

    var updatePosition = function updatePosition() {
      if (_this10.popperInstance) {
        _this10.popperInstance.scheduleUpdate();
      }

      applyTransitionDuration$$1();

      if (_this10.state.visible) {
        requestAnimationFrame(updatePosition);
      } else {
        removeTransitionDuration();
      }
    };

    // Wait until the popper's position has been updated initially
    defer(updatePosition);
  }

  /**
   * Adds a mutation observer to an element and stores it in the instance
   * @param {Object}
   * @memberof Tippy
   * @private
   */
  function _addMutationObserver(_ref2) {
    var target = _ref2.target,
        callback = _ref2.callback,
        options = _ref2.options;

    if (!window.MutationObserver) return;

    var observer = new MutationObserver(callback);
    observer.observe(target, options);

    this._(key).mutationObservers.push(observer);
  }

  /**
   * Fires the callback functions once the CSS transition ends for `show` and `hide` methods
   * @param {Number} duration
   * @param {Function} callback - callback function to fire once transition completes
   * @memberof Tippy
   * @private
   */
  function _onTransitionEnd(duration, callback) {
    // Make callback synchronous if duration is 0
    if (!duration) {
      return callback();
    }

    var _getInnerElements4 = getInnerElements(this.popper),
        tooltip = _getInnerElements4.tooltip;

    var toggleListeners = function toggleListeners(action, listener) {
      if (!listener) return;
      tooltip[action + 'EventListener']('ontransitionend' in window ? 'transitionend' : 'webkitTransitionEnd', listener);
    };

    var listener = function listener(e) {
      if (e.target === tooltip) {
        toggleListeners('remove', listener);
        callback();
      }
    };

    toggleListeners('remove', this._(key).transitionendListener);
    toggleListeners('add', listener);

    this._(key).transitionendListener = listener;
  }

  return {
    Tippy: Tippy,
    _getEventListeners: _getEventListeners,
    _addMutationObserver: _addMutationObserver,
    _createPopperInstance: _createPopperInstance,
    _onTransitionEnd: _onTransitionEnd
  };
})();

var Tippy = T.Tippy;
var _getEventListeners = T._getEventListeners;
var _createPopperInstance = T._createPopperInstance;
var _addMutationObserver = T._addMutationObserver;

var idCounter = 1;

/**
 * Creates tooltips for each reference element
 * @param {Element[]} els
 * @param {Object} config
 * @return {Tippy[]} Array of Tippy instances
 */
function createTooltips(els, config) {
  return els.reduce(function (acc, reference) {
    var id = idCounter;

    var options = evaluateOptions(reference, config.performance ? config : getIndividualOptions(reference, config));

    var html = options.html,
        trigger = options.trigger,
        touchHold = options.touchHold,
        dynamicTitle = options.dynamicTitle,
        createPopperInstanceOnInit = options.createPopperInstanceOnInit;

    var title = reference.getAttribute('title');
    if (!title && !html) return acc;

    reference.setAttribute('data-tippy', '');
    reference.setAttribute('aria-describedby', 'tippy-' + id);

    removeTitle(reference);

    var popper = createPopperElement(id, title, options);

    var tippy = new Tippy({
      id: id,
      reference: reference,
      popper: popper,
      options: options
    });

    tippy.popperInstance = createPopperInstanceOnInit ? _createPopperInstance.call(tippy) : null;

    var listeners = _getEventListeners.call(tippy);
    tippy.listeners = trigger.trim().split(' ').reduce(function (acc, eventType) {
      return acc.concat(createTrigger(eventType, reference, listeners, touchHold));
    }, []);

    // Update tooltip content whenever the title attribute on the reference changes
    if (dynamicTitle) {
      _addMutationObserver.call(tippy, {
        target: reference,
        callback: function callback() {
          var _getInnerElements = getInnerElements(popper),
              content = _getInnerElements.content;

          var title = reference.getAttribute('title');
          if (title) {
            content.innerHTML = title;
            removeTitle(reference);
          }
        },

        options: {
          attributes: true
        }
      });
    }

    // Shortcuts
    reference._tippy = tippy;
    popper._reference = reference;

    acc.push(tippy);

    idCounter++;

    return acc;
  }, []);
}

/**
 * Hides all poppers
 * @param {Tippy} excludeTippy - tippy to exclude if needed
 */
function hideAllPoppers(excludeTippy) {
  var poppers = [].slice.call(document.querySelectorAll(selectors.POPPER));

  poppers.forEach(function (popper) {
    var tippy = popper._reference._tippy;
    var options = tippy.options;

    if ((options.hideOnClick === true || options.trigger.indexOf('focus') > -1) && (!excludeTippy || popper !== excludeTippy.popper)) {
      tippy.hide();
    }
  });
}

/**
 * Adds the needed event listeners
 */
function bindEventListeners() {
  var touchHandler = function touchHandler() {
    if (browser.usingTouch) return;

    browser.usingTouch = true;

    if (browser.iOS) {
      document.body.classList.add('tippy-touch');
    }

    if (browser.dynamicInputDetection && window.performance) {
      document.addEventListener('mousemove', mousemoveHandler);
    }

    browser.onUserInputChange('touch');
  };

  var mousemoveHandler = function () {
    var time = void 0;

    return function () {
      var now = performance.now();

      // Chrome 60+ is 1 mousemove per animation frame, use 20ms time difference
      if (now - time < 20) {
        browser.usingTouch = false;
        document.removeEventListener('mousemove', mousemoveHandler);
        if (!browser.iOS) {
          document.body.classList.remove('tippy-touch');
        }
        browser.onUserInputChange('mouse');
      }

      time = now;
    };
  }();

  var clickHandler = function clickHandler(event) {
    // Simulated events dispatched on the document
    if (!(event.target instanceof Element)) {
      return hideAllPoppers();
    }

    var reference = closest(event.target, selectors.REFERENCE);
    var popper = closest(event.target, selectors.POPPER);

    if (popper && popper._reference._tippy.options.interactive) return;

    if (reference) {
      var options = reference._tippy.options;

      // Hide all poppers except the one belonging to the element that was clicked IF
      // `multiple` is false AND they are a touch user, OR
      // `multiple` is false AND it's triggered by a click

      if (!options.multiple && browser.usingTouch || !options.multiple && options.trigger.indexOf('click') > -1) {
        return hideAllPoppers(reference._tippy);
      }

      if (options.hideOnClick !== true || options.trigger.indexOf('click') > -1) return;
    }

    hideAllPoppers();
  };

  var blurHandler = function blurHandler(event) {
    var _document = document,
        el = _document.activeElement;

    if (el && el.blur && matches$1.call(el, selectors.REFERENCE)) {
      el.blur();
    }
  };

  document.addEventListener('click', clickHandler);
  document.addEventListener('touchstart', touchHandler);
  window.addEventListener('blur', blurHandler);

  if (!browser.supportsTouch && (navigator.maxTouchPoints || navigator.msMaxTouchPoints)) {
    document.addEventListener('pointerdown', touchHandler);
  }
}

/**
 * Creates tooltips
 * @param {String|Element|Element[]|NodeList|Object} selector
 * @param {Object} options
 * @return {Object}
 */
function tippy$2(selector, options) {
  if (browser.supported && !browser._eventListenersBound) {
    bindEventListeners();
    browser._eventListenersBound = true;
  }

  if (isObjectLiteral(selector)) {
    selector.refObj = true;
    selector.attributes = selector.attributes || {};
    selector.setAttribute = function (key, val) {
      selector.attributes[key] = val;
    };
    selector.getAttribute = function (key) {
      return selector.attributes[key];
    };
    selector.removeAttribute = function (key) {
      delete selector.attributes[key];
    };
    selector.addEventListener = function () {};
    selector.removeEventListener = function () {};
    selector.classList = {
      classNames: {},
      add: function add(key) {
        return selector.classList.classNames[key] = true;
      },
      remove: function remove(key) {
        delete selector.classList.classNames[key];
        return true;
      },
      contains: function contains(key) {
        return !!selector.classList.classNames[key];
      }
    };
  }

  options = _extends({}, defaults, options);

  return {
    selector: selector,
    options: options,
    tooltips: browser.supported ? createTooltips(getArrayOfElements(selector), options) : [],
    destroyAll: function destroyAll() {
      this.tooltips.forEach(function (tooltip) {
        return tooltip.destroy();
      });
      this.tooltips = [];
    }
  };
}

tippy$2.browser = browser;
tippy$2.defaults = defaults;

return tippy$2;

})));


text:
Dipper
======

Dipper is a tool for dumping data from SQL databases in a smart way.

Screenshots
-----------

Dumping a whole table:

    $ dipper --database mysql://test:secret@127.0.0.1:3306/test \
             --table things \
             --columns id,name
    1       Thing #1
    2       Thing #2

Using config files:

    $ cat dipper.ini
    [dipper]
    username = test
    password = secret

    $ dipper --database mysql://127.0.0.1/test \
             --table things \
             --config dipper.ini
    1       Thing #1
    2       Thing #2

Using environment variables for default values:

    $ export DIPPER_DATABASE=mysql://127.0.0.1/test

    $ dipper --config dipper.ini --table things
    1       Thing #1
    2       Thing #2

Receipts capture the last incremental dump state:

    $ dipper --config dipper.ini --table things \
             --incremental id \
             --receipt things.receipt
    1       Thing #1
    2       Thing #2

    $ cat things.receipt
    [receipt]
    table = things
    incremental = id
    last-value = 2

    $ dipper --config dipper.ini --table things \
             --incremental id \
             --receipt things.receipt

The last run had no output because all known record had already been dumped.
Lest's add a new one.

    $ mysql -e 'INSERT INTO things (id, name) VALUES (3, "No Thing")'

    $ dipper --config dipper.ini --table things \
             --incremental id \
             --receipt things.receipt
    3       No Thing

    $ cat things.receipt
    [receipt]
    table = things
    incremental = id
    last-value = 3

Supported Databases
-------------------

* MySQL - yes
* SQLite3 - yes
* PostgreSQL - not yet
* ODBC - planned

Usage
-----

    dipper [options]

    Options:
        --help                         Show this text and exit.
        --database=DATABASE            Database connection URI
        --table=TABLE                  Table name
        --columns=COL1,COL2,...,COLN   A comma-separated column list
        --incremental=COLUMN           Do an incremental dump using this column
        --last-value=VALUE             The last seen value in the incremental column
        --limit=N                      Limit results to the N first rows (debug only)
        --username=USERNAME            Log in to DATABASE as USERNAME
        --password=PASSWORD            Log in to DATABASE using PASSWORD
        --output=PATH                  Store results to PATH. Default: stdout
        --receipt=PATH                 Read and write receipt file at PATH
        --config=PATH                  Read config from PATH

Installation
------------

Coming soon...

License
-------

This software is covered by the [MIT](./LICENSE) license.


text:
package com.tngtech.archunit.lang.syntax.elements;

import com.tngtech.archunit.PublicAPI;
import com.tngtech.archunit.base.DescribedPredicate;
import com.tngtech.archunit.core.domain.JavaMember;
import com.tngtech.archunit.core.domain.properties.HasName;
import com.tngtech.archunit.lang.ArchCondition;
import com.tngtech.archunit.lang.conditions.ArchConditions;
import com.tngtech.archunit.lang.syntax.ArchRuleDefinition;

import static com.tngtech.archunit.PublicAPI.Usage.ACCESS;

@PublicAPI(usage = ACCESS)
public interface GivenMembers<MEMBER extends JavaMember> extends GivenObjects<MEMBER> {

    /**
     * Allows to restrict the set of members under consideration. E.g.
     *

     *

     * {@link ArchRuleDefinition#members() members()}.{@link GivenMembers#that() that()}.{@link MembersThat#haveName(String) haveName("foo")}
     *

     *
     * @return A syntax element, which can be used to restrict the members under consideration
     */
    @PublicAPI(usage = ACCESS)
    MembersThat<? extends GivenMembersConjunction<MEMBER>> that();

    /**
     * Allows to restrict the set of members under consideration. E.g.
     *

     *

     * {@link ArchRuleDefinition#members() members()}.{@link GivenMembers#that(DescribedPredicate) that(haveName("foo"))}
     *

     *
     * Note that many predefined {@link DescribedPredicate predicates} can be found within a subclass {@code Predicates} of the
     * respective domain object or a common ancestor. For example, {@link DescribedPredicate predicates} targeting
     * {@link JavaMember} can be found within {@link JavaMember.Predicates} or one of the respective ancestors
     * like {@link HasName.Predicates}.
     *
     * @return A syntax conjunction element, which can be completed to form a full rule
     */
    @Override
    @PublicAPI(usage = ACCESS)
    GivenMembersConjunction<MEMBER> that(DescribedPredicate<? super MEMBER> predicate);

    /**
     * Allows to specify assertions for the set of members under consideration. E.g.
     *

     *

     * {@link ArchRuleDefinition#members() members()}.{@link GivenMembers#should() should()}.{@link MembersShould#haveName(String) haveName("foo")}
     *

     *
     * @return A syntax element, which can be used to restrict the members under consideration
     */
    @PublicAPI(usage = ACCESS)
    MembersShould<? extends MembersShouldConjunction<MEMBER>> should();

    /**
     * Allows to specify assertions for the set of members under consideration. E.g.
     *

     *

     * {@link ArchRuleDefinition#members() members()}.{@link GivenMembers#should(ArchCondition) should(haveName("foo"))}
     *

     *
     * Predefined conditions to customize and join can be found within {@link ArchConditions}.
     *
     * @return A syntax element, which can be used to restrict the members under consideration
     */
    @Override
    @PublicAPI(usage = ACCESS)
    MembersShouldConjunction<MEMBER> should(ArchCondition<? super MEMBER> condition);
}


text:
name: Rapport pour toute autre raison
about: Décrire votre demande

---