text:
title: Core Concepts
author: Tim Holy
order: 40
...

Julia Images Guide

# The basic types

## Plain arrays

Images can be plain arrays, which are interpreted to be in "Matlab format": the
first two dimensions are height (`h`) and width (`w`), a storage order here
called "vertical-major". This ordering is inspired by the column/row index order
of matrices and the desire to have a displayed image look like what one sees
when a matrix is written out in text.

If you're working with RGB color, your best approach is to encode color as a
`ColorValue`, as defined in the `Color` package.  That package provides many
utility functions for analyzing and manipulating colors.  Alternatively, you can
use a third dimension of size 3, or encode your images as either `RGB24` or
`ARGB32`, which use an internal `Uint32` representation of color.

It's worth noting that these Matlab conventions are sometimes inconvenient.  For
example, the `x` coordinate (horizontal) is second and the `y` coordinate
(vertical) is first; in other words, one uses `img[y,x]` to address a pixel that
is displayed at a particular `x,y` position. This often catches newcomers (and
sometimes even old-timers) by surprise.  Moreover, most image file formats,
cameras, and graphics libraries such as Cairo use "horizontal-major" storage of
images, and have the color dimension first (fastest). The native Image
type---which allows arbitrary ordering of the data array---permits you to use
this raw representation directly, but when using plain arrays you need to
permute the dimensions of the raw data array.

The convention that a `m x n x 3` array implies RGB is also problematic for
anyone doing 3d imaging, and can result in hard-to-find bugs when the third
dimension happens to be of size 3. For 3d imaging, the use of an Image
type---perhaps converting Arrays via `grayim`---is highly recommended.

The conventions for plain arrays are "baked in" via a few simple utility
functions in the file `core.jl`; if you really need to use plain arrays but want
to work with different conventions, you can (locally) change these defaults with
just a few lines. Algorithms which have been written generically should continue
to work.

However, a more flexible approach is to use one of the self-documenting image
types.

## Image types

All image types should descend from `AbstractImage`, an abstract base type used
to indicate that an array is to be interpreted as an image. If you're writing a
custom image type, it is more likely that you'll want to derive from either
`AbstractImageDirect` or `AbstractImageIndexed`. The former is for direct images
(where intensity at a pixel is represented directly), the latter for indexed
images (where intensity is looked up in a colormap table).

In practice, it is assumed that `AbstractImages` have at least two fields,
called `data` and `properties`. (In code, you should not use these directly,
instead using the functions `data` and `properties` to extract these.)  These
are the only two fields in the first concrete image type, called `Image`:

```{.julia execute="false"}
type Image{T,N,A<:AbstractArray} <: AbstractImageDirect{T,N}
    data::A
    properties::Dict{ASCIIString,Any}
end
```

`data` stores the actual image data, and is an `AbstractArray`. This fact alone
is the basis for a great deal of customizability: `data` might be a plain
`Array` stored in memory, a `SubArray`, a memory-mapped array (which is still
just an `Array`), a custom type that stores additional information about
"missing data" (like bad pixels or dropped frames), or a custom type that
seamlessly presents views of a large number of separate files.  One concrete
example in the Images codebase is the color `Overlay` [type](overlays.md).  If
you have a suitably-defined `AbstractArray` type, you can probably use `Image`
without needing to create alternative `AbstractImageDirect` types.

`properties` is a dictionary, with `String` keys, that allows you to annotate
images. More detail about this point can be found below.

The only other concrete image type is for indexed images:

```{.julia execute="false"}
type ImageCmap{T,N,A<:AbstractArray,C<:AbstractArray} <: AbstractImageIndexed{T,N}
    data::A
    cmap::C
    properties::Dict{ASCIIString,Any}
end
```

The `data` array here just encodes the index used to look up the color in the
`cmap` field.

# Addressing image data

For any valid image type, `data(img)` returns the array that corresponds to the
image.  This works when `img` is a plain `Array` (in which case no operation is
performed) as well as for an `Image` (in which case it returns `img.data`).
This is our first example of how to write generic algorithms.

If `img` is an `Image`, then `img[i,j]` looks up the value `img.data[i,j]`.
Assignment, `sub`, and `slice` work similarly. In other words, for indexing an
`Image` works just as if you were using plain arrays.

If you load your image data using Image's `imread`, note that the storage order
is not changed from the on-disk representation. Therefore, a 2D RGB image will
most likely be stored in color-horizontal-vertical order, meaning that a pixel
at `(x,y)` is accessed as `img[x,y]`. Note that this is quite different from
Matlab's default representation.

If you are indexing over an extended region and want to get back an `Image`,
rather than a value or an `Array`, then you will want to use `getindexim`,
`subim`, and `sliceim`. For the first two, the resulting image will share
everything but the `data` field with the original image; if you make
modifications in one, the other will also be affected. For `sliceim`, because it
can change the dimensionality some adjustments to `properties` are needed; in
this case a copy is made.

One of the properties (see below) that you can grant to images is
`spatialorder`, which provides a name for each spatial dimension in the image.
Using this feature, you can cut out regions or slices from images in the
following ways:

```{.julia execute="false"}
A = img["x", 200:400, "y", 500:700]
imgs = sliceim(img, "z", 14)      # cuts out the 14th frame in a stack
```

These routines "do the right thing" no matter what storage order is being used.

# Image properties and accessor functions

The `properties` dictionary can contain any information you want to store along
with your images. Typically, each property is also affiliated with an accessor
function of the same name.

Let's illustrate this with one of the default properties, `"colorspace"`.
The value of this property is a string, such as `"RGB"` or `"Gray"` or `"HSV"`.
You can extract the value of this field using a function:

```{.julia execute="false"}
cs = colorspace(img)
```

The reason to have a function, rather than just looking it up in the
`properties` dictionary, is that we can provide defaults. For example, images
represented as plain `Array`s don't have a `properties` dictionary; if we are to
write generic code, we don't want to have to wonder whether this information is
available. So for plain arrays, there are a number of defaults specified for the
output of the `colorspace` function, depending on the element type and size of
the array. Likewise, images stored as `ColorValue` arrays have no need of a
`"colorspace"` property, because the colorspace is encoded in the type
parameters.

Here is a list of the properties supported in `core.jl`:

- `colorspace`: "RGB", "RGBA", "Gray", "Binary", "24bit", "Lab", "HSV", etc.  If
  your image is represented as a ColorValue array, you cannot override that
  choice by specifying a `colorspace` property.  (Use `reinterpret` if you want
  to change the interpretation without changing the raw values.)
- `colordim`: the array dimension used to store color information, or 0 if there
  is no dimension corresponding to color
- `timedim`: the array dimension used for time (i.e., sequence), or 0 for single
  images
- `scalei`: a property that controls default contrast scaling upon display.
  This should be a
  [`MapInfo`](https://github.com/timholy/Images.jl/blob/master/doc/function_reference.md#intensity-scaling)
  value, to be used for setting the contrast upon display. In the absence of
  this property, the range 0 to 1 will be used.
- `pixelspacing`: the spacing between adjacent pixels along spatial dimensions
- `spacedirections`: more detailed information about the orientation of array
  axes relative to an external coordinate system (see the
  [function reference](function_reference.md)).
- `spatialorder`: a string naming each spatial dimension of the array, in the
  storage order of the data array.  Names can be arbitrary, but the choices "x"
  and "y" have special meaning (horizontal and vertical, respectively,
  irrespective of storage order).  If supplied, you must have one entry per
  spatial dimension.

If you specify their values in the `properties` dictionary, your values will be
used; if not, hopefully-reasonable defaults will be chosen.

Naturally, you can add whatever additional properties you want: you could add
the date/time at which the image was captured, the patient ID, etc. The main
point of having a properties dictionary, rather than a type with fixed fields,
is the flexibility of adding whatever metadata you find to be useful.

# Writing generic algorithms

Let's say you have an algorithm implemented for `Array`s, and you want to extend
it to work on `Image` types. Let's consider the example of a hypothetical
`imfilter`, written to perform kernel-based filtering in arbitrary dimensions.
Let's say your `imfilter` looks like this:

```{.julia execute="false"}
function imfilter{T,N}(A::Array{T,N}, kernel::Array{T,N}, options...)
```

The first step might be to simply provide a version for `AbstractImage` types:

```{.julia execute="false"}
function imfilter{T,N}(img::AbstractImage{T,N}, kernel::Array{T,N}, options...)
    out = imfilter(data(img), kernel, options...)
    shareproperties(img, out)
end
```

Now let's say you additionally want to allow the user to filter color
images---where one dimension of the array is used to encode color---with a
filter of dimension `N-1` applied to each color channel separately. We can
implement this version simultaneously for both `Image` types and other array
types as follows:

```{.julia execute="false"}
function imfilter{T,N,N1}(img::AbstractArray{T,N}, kernel::Array{T,N1}, options...)
    cd = colordim(img)
    if N1 != N - (cd != 0)
        error("kernel has the wrong dimensionality")
    end
    out = similar(img)
    for i = size(img, cd)
        imsl = img["color", i]
        outsl = slice(out, "color", i)
        copy!(outsl, imfilter(imsl, kernel, options...))
    end
    out
end
```

There are other ways to achieve a similar effect; if you examine the actual
implementation of `imfilter`, you'll see that the kernel is reshaped to be
commensurate with the data array.

These solutions work no matter which dimension is used to store color, a feat
that would be essentially impossible to achieve robustly in a generic algorithm
if we didn't exploit metadata. Note also that if the user supplies an `Array`,
s/he will get an `Array` back, and if using an `Image` will get an `Image` back
with properties inherited from `img`.

Naturally, you can find other examples of generic implementations throughout the
source code of `Images`.


text:
<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');

class User_data extends CI_Controller {

 function __construct()
 {
   parent::__construct();
   $this->load->helper(array('form', 'url'));
   $this->load->library('form_validation');
   $this->load->model('user','',TRUE);
   $this->load->model('group_model','',TRUE);
   if(!$this->session->userdata('logged_in'))
   {
   redirect('login');
   }
 }

 function index($limit='0')
 {
 $logged_in=$this->session->userdata('logged_in');
 $data['username'] = $logged_in['username'];
if($logged_in['su']!="1"){
exit('Permission denied');
return;
}
   $data['result'] = $this->user->user_list($limit);
	$data['title']="User list";
   $data['limit']=$limit;
   $this->load->view($this->session->userdata('web_view').'/header',$data);
   $this->load->view($this->session->userdata('web_view').'/user_list',$data);
  	$this->load->view($this->session->userdata('web_view').'/footer',$data);
 }

  function login_user_by_admin($id){
   $logged_in=$this->session->userdata('logged_in');
   $data['username'] = $logged_in['username'];

  if($logged_in['su']!="1"){
	exit('Permission denied');
	return;
	}
   $result = $this->user->login_user_by_admin($id);

     $sess_array = array();
     foreach($result as $row)
     {
       $sess_array = array(
         'id' => $row->id,
         'username' => $row->username,
         'gid'=> $row->gid,
         'su'=> $row->su
       );
       $this->session->set_userdata('logged_in', $sess_array);

	   }
	   redirect('home');

  }

function remove_user($id){
$logged_in=$this->session->userdata('logged_in');
if($logged_in['su']!="1"){
exit('Permission denied');
return;
}

			$this->user->remove_user($id);

	redirect('user_data', 'refresh');
}

// add new user form
function add_new(){
$logged_in=$this->session->userdata('logged_in');
  $data['username'] = $logged_in['username'];
if($logged_in['su']!="1"){
exit('Permission denied');
return;
}
	$data['title']="Add User";
	//get the list of the groups
	$data['allgroups'] = $this->group_model->get_allgroups();
	$this->load->view($this->session->userdata('web_view').'/header',$data);
	$this->load->view($this->session->userdata('web_view').'/add_user',$data);
	$this->load->view($this->session->userdata('web_view').'/footer',$data);
	}

// insert user into database
function insert_user(){
$logged_in=$this->session->userdata('logged_in');
  $data['username'] = $logged_in['username'];
if($logged_in['su']!="1"){
exit('Permission denied');
return;
}

	//echo "<pre>"; print_r($_POST);
	// form validation rules
	$this->form_validation->set_rules('username', 'Username', 'required|min_length[4]|is_unique[users.username]');
	$this->form_validation->set_rules('user_password', 'Password', 'required|matches[confirm_password]');
	$this->form_validation->set_rules('confirm_password', 'Confirm Password', 'required');
	$this->form_validation->set_rules('first_name', 'First Name', 'required');
	$this->form_validation->set_rules('last_name', 'Last Name', 'required');
	$this->form_validation->set_rules('user_credit', 'Credit', 'required');
	$this->form_validation->set_rules('user_email', 'Email', 'required|valid_email|is_unique[users.email]');
	if ($this->form_validation->run() == FALSE)
		{
			$this->add_new();
		}
		else
		{
		$data['title']="Add User";
		$data['resultstatus'] = $this->user->insert_user();
		$this->load->view($this->session->userdata('web_view').'/header',$data);
		$this->load->view($this->session->userdata('web_view').'/add_user',$data);
		$this->load->view($this->session->userdata('web_view').'/footer',$data);
		}
	}

	// edit the user form
	public function edit_user($user_id,$resultstatus=''){
$logged_in=$this->session->userdata('logged_in');
 $data['username'] = $logged_in['username'];

if($logged_in['su']!="1"){
exit('Permission denied');
return;
}
	$logged_in=$this->session->userdata('logged_in');
		$data['title']="Edit User";
					$institute_id =$this->session->userdata('institute_id');
			$data['user'] = $this->user->get_user($user_id,$institute_id);
	$data['allgroups'] = $this->group_model->get_allgroups();
		$data['user_id'] = $user_id;
		$data['resultstatus'] = $resultstatus;
		$data['su']=$logged_in['su'];
		$this->load->view($this->session->userdata('web_view').'/header',$data);
		$this->load->view($this->session->userdata('web_view').'/edit_user',$data);
		$this->load->view($this->session->userdata('web_view').'/footer',$data);
		}

	// edit the user form
	public function my_account($resultstatus=''){
		$data['title']="Edit User";
		$logged_in=$this->session->userdata('logged_in');
		$user_id=$logged_in['id'];
		$institute_id =$this->session->userdata('institute_id');
		$data['user'] = $this->user->get_user($user_id,$institute_id);
		$data['allgroups'] = $this->group_model->get_allgroups();
		$data['user_id'] = $user_id;
		$data['resultstatus'] = $resultstatus;
		$data['su']=$logged_in['su'];
		$this->load->view($this->session->userdata('web_view').'/header',$data);
		$this->load->view($this->session->userdata('web_view').'/edit_user',$data);
		$this->load->view($this->session->userdata('web_view').'/footer',$data);
		}

	// update user in database
	function update_user($user_id){
		// form validations
		$logged_in=$this->session->userdata('logged_in');
		if($logged_in['su']=="0"){
		$user_id=$logged_in['id'];
		}
		$this->form_validation->set_rules('username', 'Username', 'required|min_length[4]');
		$this->form_validation->set_rules('first_name', 'First Name', 'required');
		$this->form_validation->set_rules('last_name', 'Last Name', 'required');
		$this->form_validation->set_rules('user_credit', 'Credit', 'required');
		$this->form_validation->set_rules('user_email', 'Email', 'required|valid_email');
		$this->form_validation->set_rules('user_password', 'Password', 'matches[confirm_password]');
		$this->form_validation->set_rules('confirm_password', 'Confirm Password','matches[user_password]');

		if ($this->form_validation->run() == FALSE){
			if($logged_in['su']=="0"){
				$this->my_account();
			}else{
			$this->edit_user($user_id);
			}
			}else{
			$resultstatus = $this->user->update_user($user_id);
			//$this->edit_user($user_id,$resultstatus);
				if($logged_in['su']=="0"){
			$this->my_account($resultstatus);
			}else{
			$this->edit_user($user_id,$resultstatus);

				}

				}
		}
}

?>

redpajama_set_name: RedPajamaGithub


text:
package com.amazonaws.services.location.model;

import java.io.Serializable;
import javax.annotation.Generated;
import com.amazonaws.protocol.StructuredPojo;
import com.amazonaws.protocol.ProtocolMarshaller;

/**
 *

 * An error corresponding to the calculation of a route between the DeparturePosition and
 * DestinationPosition.
 *

 *

 * The error code can be one of the following:
 *

 *

 *

 *

 * RouteNotFound - Unable to find a valid route with the given parameters.
 *

 *

 *

 *

 *

 *

 * RouteTooLong - Route calculation went beyond the maximum size of a route and was terminated before
 * completion.
 *

 *

 *

 *

 *

 *

 * PositionsNotFound - One or more of the input positions were not found on the route network.
 *

 *

 *

 *

 *

 *

 * DestinationPositionNotFound - The destination position was not found on the route network.
 *

 *

 *

 *

 *

 *

 * DeparturePositionNotFound - The departure position was not found on the route network.
 *

 *

 *

 *

 *

 *

 * OtherValidationError - The given inputs were not valid or a route was not found. More information is
 * given in the error Message
 *

 *

 *

 *
 * @see AWS API
 *      Documentation
 */
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class RouteMatrixEntryError implements Serializable, Cloneable, StructuredPojo {

    /**
     *

     * The type of error which occurred for the route calculation.
     *

     */
    private String code;
    /**
     *

     * A message about the error that occurred for the route calculation.
     *

     */
    private String message;

    /**
     *

     * The type of error which occurred for the route calculation.
     *

     *
     * @param code
     *        The type of error which occurred for the route calculation.
     * @see RouteMatrixErrorCode
     */

    public void setCode(String code) {
        this.code = code;
    }

    /**
     *

     * The type of error which occurred for the route calculation.
     *

     *
     * @return The type of error which occurred for the route calculation.
     * @see RouteMatrixErrorCode
     */

    public String getCode() {
        return this.code;
    }

    /**
     *

     * The type of error which occurred for the route calculation.
     *

     *
     * @param code
     *        The type of error which occurred for the route calculation.
     * @return Returns a reference to this object so that method calls can be chained together.
     * @see RouteMatrixErrorCode
     */

    public RouteMatrixEntryError withCode(String code) {
        setCode(code);
        return this;
    }

    /**
     *

     * The type of error which occurred for the route calculation.
     *

     *
     * @param code
     *        The type of error which occurred for the route calculation.
     * @return Returns a reference to this object so that method calls can be chained together.
     * @see RouteMatrixErrorCode
     */

    public RouteMatrixEntryError withCode(RouteMatrixErrorCode code) {
        this.code = code.toString();
        return this;
    }

    /**
     *

     * A message about the error that occurred for the route calculation.
     *

     *
     * @param message
     *        A message about the error that occurred for the route calculation.
     */

    public void setMessage(String message) {
        this.message = message;
    }

    /**
     *

     * A message about the error that occurred for the route calculation.
     *

     *
     * @return A message about the error that occurred for the route calculation.
     */

    public String getMessage() {
        return this.message;
    }

    /**
     *

     * A message about the error that occurred for the route calculation.
     *

     *
     * @param message
     *        A message about the error that occurred for the route calculation.
     * @return Returns a reference to this object so that method calls can be chained together.
     */

    public RouteMatrixEntryError withMessage(String message) {
        setMessage(message);
        return this;
    }

    /**
     * Returns a string representation of this object. This is useful for testing and debugging. Sensitive data will be
     * redacted from this string using a placeholder value.
     *
     * @return A string representation of this object.
     *
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("{");
        if (getCode() != null)
            sb.append("Code: ").append(getCode()).append(",");
        if (getMessage() != null)
            sb.append("Message: ").append(getMessage());
        sb.append("}");
        return sb.toString();
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;

        if (obj instanceof RouteMatrixEntryError == false)
            return false;
        RouteMatrixEntryError other = (RouteMatrixEntryError) obj;
        if (other.getCode() == null ^ this.getCode() == null)
            return false;
        if (other.getCode() != null && other.getCode().equals(this.getCode()) == false)
            return false;
        if (other.getMessage() == null ^ this.getMessage() == null)
            return false;
        if (other.getMessage() != null && other.getMessage().equals(this.getMessage()) == false)
            return false;
        return true;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int hashCode = 1;

        hashCode = prime * hashCode + ((getCode() == null) ? 0 : getCode().hashCode());
        hashCode = prime * hashCode + ((getMessage() == null) ? 0 : getMessage().hashCode());
        return hashCode;
    }

    @Override
    public RouteMatrixEntryError clone() {
        try {
            return (RouteMatrixEntryError) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new IllegalStateException("Got a CloneNotSupportedException from Object.clone() " + "even though we're Cloneable!", e);
        }
    }

    @com.amazonaws.annotation.SdkInternalApi
    @Override
    public void marshall(ProtocolMarshaller protocolMarshaller) {
        com.amazonaws.services.location.model.transform.RouteMatrixEntryErrorMarshaller.getInstance().marshall(this, protocolMarshaller);
    }
}


text:
package org.apache.webbeans.test.portable.injectiontarget;

import javax.enterprise.event.Observes;

public class PersonModel
{
    private static int eventCount;

    public static int getEventCount()
    {
        return eventCount;
    }

    public void observe(@Observes String event)
    {
        eventCount++;
    }
}


text:
import React from 'react'
import PropTypes from 'prop-types'

export const PageLayout = ({ children }) => (
  <div >
    {children}
  </div>
)
PageLayout.propTypes = {
  children: PropTypes.node
}

export default PageLayout


text:
/**
 * @fileoverview Definitions for components of the WebRTC browser API.
 * @see https://www.w3.org/TR/webrtc/
 * @see https://tools.ietf.org/html/draft-ietf-rtcweb-jsep-19
 * @see https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API
 * @see https://www.w3.org/TR/mediacapture-streams/
 *
 * @externs
 * @author bemasc@google.com (Benjamin M. Schwartz)
 */

/**
 * @typedef {string}
 * @see {https://www.w3.org/TR/mediacapture-streams/
 *     #idl-def-MediaStreamTrackState}
 * In WebIDL this is an enum with values 'live', 'mute', and 'ended',
 * but there is no mechanism in Closure for describing a specialization of
 * the string type.
 */
var MediaStreamTrackState;

/**
 * @interface
 */
function SourceInfo() {}

/** @const {string} */
SourceInfo.prototype.kind;

/** @const {string} */
SourceInfo.prototype.id;

/** @const {?string} */
SourceInfo.prototype.label;

/** @const {boolean} */
SourceInfo.prototype.facing;

/**
 * @interface
 * @see https://w3c.github.io/mediacapture-image/#mediasettingsrange-section
 */
function MediaSettingsRange() {}

/**
 * @type {number}
 * @const
 */
MediaSettingsRange.prototype.max;

/**
 * @type {number}
 * @const
 */
MediaSettingsRange.prototype.min;

/**
 * @type {number}
 * @const
 */
MediaSettingsRange.prototype.step;

/**
 * @interface
 * @see https://www.w3.org/TR/mediacapture-streams/#idl-def-MediaTrackCapabilities
 * @see https://w3c.github.io/mediacapture-image/#mediatrackcapabilities-section
 */
function MediaTrackCapabilities() {}

/** @type {number} */
MediaTrackCapabilities.prototype.width;

/** @type {number} */
MediaTrackCapabilities.prototype.height;

/** @type {number} */
MediaTrackCapabilities.prototype.aspectRatio;

/** @type {number} */
MediaTrackCapabilities.prototype.frameRate;

/** @type {!Array<string>} */
MediaTrackCapabilities.prototype.facingMode;

/** @type {number} */
MediaTrackCapabilities.prototype.volume;

/** @type {number} */
MediaTrackCapabilities.prototype.sampleRate;

/** @type {number} */
MediaTrackCapabilities.prototype.sampleSize;

/** @type {!Array<boolean>} */
MediaTrackCapabilities.prototype.echoCancellation;

/** @type {number} */
MediaTrackCapabilities.prototype.latency;

/** @type {number} */
MediaTrackCapabilities.prototype.channelCount;

/** @type {string} */
MediaTrackCapabilities.prototype.deviceId;

/** @type {string} */
MediaTrackCapabilities.prototype.groupId;

/** @type {!Array<string>} */
MediaTrackCapabilities.prototype.whiteBalanceMode;

/** @type {!Array<string>} */
MediaTrackCapabilities.prototype.exposureMode;

/** @type {!Array<string>} */
MediaTrackCapabilities.prototype.focusMode;

/** @type {!MediaSettingsRange} */
MediaTrackCapabilities.prototype.exposureCompensation;

/** @type {!MediaSettingsRange} */
MediaTrackCapabilities.prototype.colorTemperature

/** @type {!MediaSettingsRange} */
MediaTrackCapabilities.prototype.iso

/** @type {!MediaSettingsRange} */
MediaTrackCapabilities.prototype.brightness

/** @type {!MediaSettingsRange} */
MediaTrackCapabilities.prototype.contrast

/** @type {!MediaSettingsRange} */
MediaTrackCapabilities.prototype.saturation

/** @type {!MediaSettingsRange} */
MediaTrackCapabilities.prototype.sharpness

/** @type {!MediaSettingsRange} */
MediaTrackCapabilities.prototype.zoom

/** @type {boolean} */
MediaTrackCapabilities.prototype.torch

/**
 * @interface
 * @see https://www.w3.org/TR/mediacapture-streams/#media-track-settings
 * @see https://w3c.github.io/mediacapture-image/#mediatracksettings-section
 */
function MediaTrackSettings() {}

/** @type {number} */
MediaTrackSettings.prototype.width;

/** @type {number} */
MediaTrackSettings.prototype.height;

/** @type {number} */
MediaTrackSettings.prototype.aspectRatio;

/** @type {number} */
MediaTrackSettings.prototype.frameRate;

/** @type {string} */
MediaTrackSettings.prototype.facingMode;

/** @type {number} */
MediaTrackSettings.prototype.volume;

/** @type {number} */
MediaTrackSettings.prototype.sampleRate;

/** @type {number} */
MediaTrackSettings.prototype.sampleSize;

/** @type {boolean} */
MediaTrackSettings.prototype.echoCancellation;

/** @type {number} */
MediaTrackSettings.prototype.latency;

/** @type {number} */
MediaTrackSettings.prototype.channelCount;

/** @type {string} */
MediaTrackSettings.prototype.deviceId;

/** @type {string} */
MediaTrackSettings.prototype.groupId;

/** @type {string} */
MediaTrackSettings.prototype.whiteBalanceMode;

/** @type {string} */
MediaTrackSettings.prototype.exposureMode;

/** @type {string} */
MediaTrackSettings.prototype.focusMode;

/** @type {!Array<{x: number, y: number}>} */
MediaTrackSettings.prototype.pointsOfInterest;

/** @type {number} */
MediaTrackSettings.prototype.exposureCompensation;

/** @type {number} */
MediaTrackSettings.prototype.colorTemperature

/** @type {number} */
MediaTrackSettings.prototype.iso

/** @type {number} */
MediaTrackSettings.prototype.brightness

/** @type {number} */
MediaTrackSettings.prototype.contrast

/** @type {number} */
MediaTrackSettings.prototype.saturation

/** @type {number} */
MediaTrackSettings.prototype.sharpness

/** @type {number} */
MediaTrackSettings.prototype.zoom

/** @type {boolean} */
MediaTrackSettings.prototype.torch

/**
 * @interface
 * @see https://w3c.github.io/mediacapture-main/#media-track-supported-constraints
 */
function MediaTrackSupportedConstraints() {}

/** @type {boolean|undefined} */
MediaTrackSupportedConstraints.prototype.width;

/** @type {boolean|undefined} */
MediaTrackSupportedConstraints.prototype.height;

/** @type {boolean|undefined} */
MediaTrackSupportedConstraints.prototype.aspectRatio;

/** @type {boolean|undefined} */
MediaTrackSupportedConstraints.prototype.frameRate;

/** @type {boolean|undefined} */
MediaTrackSupportedConstraints.prototype.facingMode;

/** @type {boolean|undefined} */
MediaTrackSupportedConstraints.prototype.volume;

/** @type {boolean|undefined} */
MediaTrackSupportedConstraints.prototype.sampleRate;

/** @type {boolean|undefined} */
MediaTrackSupportedConstraints.prototype.sampleSize;

/** @type {boolean|undefined} */
MediaTrackSupportedConstraints.prototype.echoCancellation;

/** @type {boolean|undefined} */
MediaTrackSupportedConstraints.prototype.autoGainControl;

/** @type {boolean|undefined} */
MediaTrackSupportedConstraints.prototype.noiseSuppression;

/** @type {boolean|undefined} */
MediaTrackSupportedConstraints.prototype.latency;

/** @type {boolean|undefined} */
MediaTrackSupportedConstraints.prototype.channelCount;

/** @type {boolean|undefined} */
MediaTrackSupportedConstraints.prototype.deviceId;

/** @type {boolean|undefined} */
MediaTrackSupportedConstraints.prototype.groupId;

/**
 * @interface
 * @extends {EventTarget}
 * @see https://www.w3.org/TR/mediacapture-streams/#mediastreamtrack
 */
function MediaStreamTrack() {}

/**
 * @param {!function(!Array<!SourceInfo>)} callback
 * @return {undefined}
 * @deprecated Use MediaDevices.enumerateDevices().
 */
MediaStreamTrack.getSources = function(callback) {};

/**
 * @type {string}
 * @const
 */
MediaStreamTrack.prototype.kind;

/**
 * @type {string}
 * @const
 */
MediaStreamTrack.prototype.id;

/**
 * @type {string}
 * @const
 */
MediaStreamTrack.prototype.label;

/**
 * @type {boolean}
 */
MediaStreamTrack.prototype.enabled;

/**
 * @type {boolean}
 * @const
 */
MediaStreamTrack.prototype.muted;

/**
 * @type {string}
 * @see https://crbug.com/653531
 * @see https://wicg.github.io/mst-content-hint/
 */
MediaStreamTrack.prototype.contentHint;

/**
 * @type {boolean}
 * @const
 */
MediaStreamTrack.prototype.remote;

/**
 * @type {MediaStreamTrackState}
 * Read only.
 */
MediaStreamTrack.prototype.readyState;

/**
 * @type {?function(!Event)}
 */
MediaStreamTrack.prototype.onmute;

/**
 * @type {?function(!Event)}
 */
MediaStreamTrack.prototype.onunmute;

/**
 * @type {?function(!Event)}
 */
MediaStreamTrack.prototype.onended;

/**
 * @type {?function(!Event)}
 */
MediaStreamTrack.prototype.onoverconstrained;

/**
 * Applies the specified set of constraints to the track, if any specified; or
 * if no constraints are specified, removes all constraints from the track.
 *
 * @param {MediaTrackConstraints=} constraints Constraints to apply to the
 *   track.
 * @return {!Promise<void>} A |Promise| that is resolved when the constraints
 *   have been applied, or rejected if there was an error applying the
 *   constraints.
 */
MediaStreamTrack.prototype.applyConstraints = function(constraints) {};

/**
 * @return {!MediaStreamTrack}
 */
MediaStreamTrack.prototype.clone = function() {};

/** @return {void} */
MediaStreamTrack.prototype.stop = function() {};

/** @return {!MediaTrackCapabilities} */
MediaStreamTrack.prototype.getCapabilities = function() {};

/** @return {!MediaTrackConstraints} */
MediaStreamTrack.prototype.getConstraints = function() {};

/** @return {!MediaTrackSettings} */
MediaStreamTrack.prototype.getSettings = function() {};

/**
 * @typedef {{track: MediaStreamTrack}}
 */
var MediaStreamTrackEventInit;

/**
 * @param {string} type
 * @param {!MediaStreamTrackEventInit} eventInitDict
 * @constructor
 * @extends {Event}
 * @see https://www.w3.org/TR/mediacapture-streams/#mediastreamtrackevent
 */
function MediaStreamTrackEvent(type, eventInitDict) {}

/**
 * @type {!MediaStreamTrack}
 * @const
 */
MediaStreamTrackEvent.prototype.track;

/**
 * @param {!MediaStream|!Array<!MediaStreamTrack>=} streamOrTracks
 * @constructor
 * @implements {EventTarget}
 * @see https://www.w3.org/TR/mediacapture-streams/#mediastream
 */
function MediaStream(streamOrTracks) {}

/**
 * @override
 */
MediaStream.prototype.addEventListener = function(type, listener,
    opt_useCapture) {};

/**
 * @override
 */
MediaStream.prototype.removeEventListener = function(type, listener,
    opt_useCapture) {};

/**
 * @override
 * @return {boolean}
 */
MediaStream.prototype.dispatchEvent = function(evt) {};

/**
 * TODO(bemasc): Remove this property.
 * @deprecated
 * @type {string}
 * @const
 */
MediaStream.prototype.label;

/**
 * @type {string}
 * @const
 */
MediaStream.prototype.id;

/**
 * @return {!Array<!MediaStreamTrack>}
 */
MediaStream.prototype.getAudioTracks = function() {};

/**
 * @return {!Array<!MediaStreamTrack>}
 */
MediaStream.prototype.getVideoTracks = function() {};

/**
 * @return {!Array<!MediaStreamTrack>}
 */
MediaStream.prototype.getTracks = function() {};

/**
 * @param {string} trackId
 * @return {MediaStreamTrack}
 */
MediaStream.prototype.getTrackById = function(trackId) {};

/**
 * @param {!MediaStreamTrack} track
 * @return {undefined}
 */
MediaStream.prototype.addTrack = function(track) {};

/**
 * @param {!MediaStreamTrack} track
 * @return {undefined}
 */
MediaStream.prototype.removeTrack = function(track) {};

/**
 * @return {!MediaStream}
 */
MediaStream.prototype.clone = function() {};

/**
 * @deprecated
 * @type {boolean}
 */
MediaStream.prototype.ended;

/**
 * @deprecated
 * @type {?function(!Event)}
 */
MediaStream.prototype.onended;

/**
 * @type {boolean}
 */
MediaStream.prototype.active;

/**
 * @type {?function(!Event)}
 */
MediaStream.prototype.onactive;

/**
 * @type {?function(!Event)}
 */
MediaStream.prototype.oninactive;

/**
 * @type {?function(!MediaStreamTrackEvent)}
 */
MediaStream.prototype.onaddtrack;

/**
 * @type {?function(!MediaStreamTrackEvent)}
 */
MediaStream.prototype.onremovetrack;

/**
 * @deprecated
 * TODO(bemasc): Remove this method once browsers have updated to
 * MediaStreamTrack.stop().
 * @return {undefined}
 */
MediaStream.prototype.stop = function() {};

/**
 * @type {function(new: MediaStream,
 *                 (!MediaStream|!Array<!MediaStreamTrack>)=)}
 */
var webkitMediaStream;

/**
 * @typedef {{tone: string}}
 * @see https://www.w3.org/TR/webrtc/#dom-rtcdtmftonechangeeventinit
 */
var RTCDTMFToneChangeEventInit;

/**
 * @param {string} type
 * @param {!RTCDTMFToneChangeEventInit} eventInitDict
 * @constructor
 * @extends {Event}
 * @see https://www.w3.org/TR/webrtc/#dom-rtcdtmftonechangeevent
 */
function RTCDTMFToneChangeEvent(type, eventInitDict) {}

/**
 * @const {string}
 */
RTCDTMFToneChangeEvent.prototype.tone;

/**
 * @interface
 * @see https://www.w3.org/TR/webrtc/#rtcdtmfsender
 */
function RTCDTMFSender() {}

/**
 * @param {string} tones
 * @param {number=} opt_duration
 * @param {number=} opt_interToneGap
 */
RTCDTMFSender.prototype.insertDTMF =
    function(tones, opt_duration, opt_interToneGap) {};

/**
 * @type {?function(!RTCDTMFToneChangeEvent)}
 */
RTCDTMFSender.prototype.ontonechange;

/**
 * @const {string}
 */
RTCDTMFSender.prototype.toneBuffer;

/**
 * @interface
 * @see https://www.w3.org/TR/webrtc/#rtcrtpsender-interface
 */
function RTCRtpSender() {}

/**
 * @const {!RTCDTMFSender}
 */
RTCRtpSender.prototype.dtmf;

/**
 * @const {!MediaStreamTrack}
 */
RTCRtpSender.prototype.track;

/**
 * @param {!MediaStreamTrack} track
 */
RTCRtpSender.prototype.replaceTrack = function(track) {};

/**
 * @return {!Object}
 */
RTCRtpSender.prototype.getParameters = function() {};

/**
 * @param {!Object} params
 * @return {!Promise<undefined>}
 */
RTCRtpSender.prototype.setParameters = function(params) {};

/**
 * @interface
 * @see https://www.w3.org/TR/webrtc/#dom-rtcrtpcontributingsource
 */
function RTCRtpContributingSource() {}

/**
 * @type {?number}
 */
RTCRtpContributingSource.prototype.source;

/**
 * @type {?Date}
 */
RTCRtpContributingSource.prototype.timestamp;

/**
 * @interface
 * @see https://www.w3.org/TR/webrtc/#rtcrtpreceiver-interface
 */
function RTCRtpReceiver() {}

/**
 * @const {!MediaStreamTrack}
 */
RTCRtpReceiver.prototype.track;

/**
 * @return {!Array<!RTCRtpContributingSource>}
 */
RTCRtpReceiver.prototype.getContributingSources = function() {};

/**
 * @return {!Array<!RTCRtpContributingSource>}
 */
RTCRtpReceiver.prototype.getSynchronizationSources = function() {};

/**
 * @see https://www.w3.org/TR/webrtc/#dom-rtcrtptransceiverinit
 * @record
 */
function RTCRtpTransceiverInit() {}

/**
 * The direction of the `RTCRtpTransceiver`. Defaults to "sendrecv".
 * @type {?RTCRtpTransceiverDirection|undefined}
 */
RTCRtpTransceiverInit.prototype.direction;

/**
 * The streams to add to the tranceiver's sender.
 * @type {?Array<!MediaStream>|undefined}
 */
RTCRtpTransceiverInit.prototype.streams;

/**
 * @type {?Array<!RTCRtpEncodingParameters>|undefined}
 */
RTCRtpTransceiverInit.prototype.sendEncodings;

/**
 * @see https://www.w3.org/TR/webrtc/#dom-rtcrtpencodingparameters
 * @record
 */
function RTCRtpEncodingParameters() {}

/**
 * @type {?number|undefined}
 */
RTCRtpEncodingParameters.prototype.codecPayloadType;

/**
 * Possible values are "disabled" and "enabled".
 * @type {?string|undefined}
 */
RTCRtpEncodingParameters.prototype.dtx;

/**
 * @type {?boolean|undefined}
 */
RTCRtpEncodingParameters.prototype.active;

/**
 * Possible values are "very-low", "low" (default), "medium", and "high".
 * @type {?string|undefined}
 */
RTCRtpEncodingParameters.prototype.priority;

/**
 * @type {?number|undefined}
 */
RTCRtpEncodingParameters.prototype.ptime;

/**
 * @type {?number|undefined}
 */
RTCRtpEncodingParameters.prototype.maxBitrate;

/**
 * @type {?number|undefined}
 */
RTCRtpEncodingParameters.prototype.maxFramerate;

/**
 * @type {?string|number}
 */
RTCRtpEncodingParameters.prototype.rid;

/**
 * @type {?number|number}
 */
RTCRtpEncodingParameters.prototype.scaleResolutionDownBy;

/**
 * @interface
 * @see https://www.w3.org/TR/webrtc/#rtcrtptransceiver-interface
 */
function RTCRtpTransceiver() {}

/**
 * @const {?string}
 */
RTCRtpTransceiver.prototype.mid;

/**
 * @const {boolean}
 */
RTCRtpTransceiver.prototype.stopped;

/**
 * @const {!RTCRtpTransceiverDirection}
 */
RTCRtpTransceiver.prototype.direction;

/**
 * @const {?RTCRtpTransceiverDirection}
 */
RTCRtpTransceiver.prototype.currentDirection;

/**
 * @param {!RTCRtpTransceiverDirection} direction
 */
RTCRtpTransceiver.prototype.setDirection = function(direction) {};

/**
 */
RTCRtpTransceiver.prototype.stop = function() {};

/**
 * @const {?RTCRtpSender}
 */
RTCRtpTransceiver.prototype.sender;

/**
 * @const {?RTCRtpReceiver}
 */
RTCRtpTransceiver.prototype.receiver;

/**
 * @see https://w3c.github.io/mediacapture-main/getusermedia.html#dom-longrange
 * @record
 */
function LongRange() {}

/**
 * @type {number|undefined}
 */
LongRange.prototype.max;

/**
 * @type {number|undefined}
 */
LongRange.prototype.min;

/**
 * @see https://w3c.github.io/mediacapture-main/getusermedia.html#dom-doublerange
 * @record
 */
function DoubleRange() {}

/**
 * @type {number|undefined}
 */
DoubleRange.prototype.max;

/**
 * @type {number|undefined}
 */
DoubleRange.prototype.min;

/**
 * @see https://w3c.github.io/mediacapture-main/getusermedia.html#dom-constrainbooleanparameters
 * @record
 */
function ConstrainBooleanParameters() {}

/**
 * @type {boolean|undefined}
 */
ConstrainBooleanParameters.prototype.exact;

/**
 * @type {boolean|undefined}
 */
ConstrainBooleanParameters.prototype.ideal;

/**
 * @see https://w3c.github.io/mediacapture-main/getusermedia.html#dom-constraindomstringparameters
 * @record
 */
function ConstrainDOMStringParameters() {}

/**
 * @type {string|Array<string>|undefined}
 */
ConstrainDOMStringParameters.prototype.exact;

/**
 * @type {string|Array<string>|undefined}
 */
ConstrainDOMStringParameters.prototype.ideal;

/**
 * @see https://w3c.github.io/mediacapture-main/getusermedia.html#dom-constraindoublerange
 * @record
 * @extends {DoubleRange}
 */
function ConstrainDoubleRange() {}

/**
 * @type {number|undefined}
 */
ConstrainDoubleRange.prototype.exact;

/**
 * @type {number|undefined}
 */
ConstrainDoubleRange.prototype.ideal;

/**
 * @see https://w3c.github.io/mediacapture-main/getusermedia.html#dom-constrainlongrange
 * @record
 * @extends {LongRange}
 */
function ConstrainLongRange() {}

/**
 * @type {number|undefined}
 */
ConstrainLongRange.prototype.exact;

/**
 * @type {number|undefined}
 */
ConstrainLongRange.prototype.ideal;

/**
 * @see https://w3c.github.io/mediacapture-main/getusermedia.html#dom-constrainboolean
 * @typedef {boolean|ConstrainBooleanParameters}
 */
var ConstrainBoolean;

/**
 * @see https://w3c.github.io/mediacapture-main/getusermedia.html#dom-constraindomString
 * @typedef {string|Array<string>|ConstrainDOMStringParameters}
 */
var ConstrainDOMString;

/**
 * @see https://w3c.github.io/mediacapture-main/getusermedia.html#dom-constraindouble
 * @typedef {number|ConstrainDoubleRange}
 */
var ConstrainDouble;

/**
 * @see https://w3c.github.io/mediacapture-main/getusermedia.html#dom-constrainlong
 * @typedef {number|ConstrainLongRange}
 */
var ConstrainLong;

/**
 * @see https://w3c.github.io/mediacapture-main/getusermedia.html#dom-mediatrackconstraintset
 * @record
 * @private
 */
function MediaTrackConstraintSet() {}

/**
 * @type {ConstrainBoolean|undefined}
 */
MediaTrackConstraintSet.prototype.autoGainControl;

/**
 * @type {ConstrainDouble|undefined}
 */
MediaTrackConstraintSet.prototype.aspectRatio;

/**
 * @type {ConstrainLong|undefined}
 */
MediaTrackConstraintSet.prototype.channelCount;

/**
 * @type {ConstrainDOMString|undefined}
 */
MediaTrackConstraintSet.prototype.deviceId;

/**
 * @type {ConstrainBoolean|undefined}
 */
MediaTrackConstraintSet.prototype.echoCancellation;

/**
 * @type {ConstrainDOMString|undefined}
 */
MediaTrackConstraintSet.prototype.facingMode;

/**
 * @type {ConstrainDouble|undefined}
 */
MediaTrackConstraintSet.prototype.frameRate;

/**
 * @type {ConstrainDOMString|undefined}
 */
MediaTrackConstraintSet.prototype.groupId;

/**
 * @type {ConstrainLong|undefined}
 */
MediaTrackConstraintSet.prototype.height;

/**
 * @type {ConstrainDouble|undefined}
 */
MediaTrackConstraintSet.prototype.latency;

/**
 * @type {ConstrainBoolean|undefined}
 */
MediaTrackConstraintSet.prototype.noiseSuppression;

/**
 * @type {ConstrainLong|undefined}
 */
MediaTrackConstraintSet.prototype.sampleRate;

/**
 * @type {ConstrainLong|undefined}
 */
MediaTrackConstraintSet.prototype.sampleSize;

/**
 * @type {ConstrainDouble|undefined}
 */
MediaTrackConstraintSet.prototype.volume;

/**
 * @type {ConstrainLong|undefined}
 */
MediaTrackConstraintSet.prototype.width;

/**
 * @record
 * @extends {MediaTrackConstraintSet}
 */
function MediaTrackConstraints() {}

/**
 * @type {Array<!MediaTrackConstraintSet>|undefined}
 */
MediaTrackConstraints.prototype.advanced;

/**
 * @see https://w3c.github.io/mediacapture-main/getusermedia.html#media-track-constraints
 * @record
 */
function MediaStreamConstraints() {}

/**
 * @type {boolean|MediaTrackConstraints|undefined}
 */
MediaStreamConstraints.prototype.audio;

/**
 * @type {boolean|MediaTrackConstraints|undefined}
 */
MediaStreamConstraints.prototype.video;

/**
 * @see {http://dev.w3.org/2011/webrtc/editor/getusermedia.html#
 *     navigatorusermediaerror-and-navigatorusermediaerrorcallback}
 * @interface
 */
function NavigatorUserMediaError() {}

/**
 * @type {number}
 * @deprecated Removed from the standard and some browsers.
 * @const
 */
NavigatorUserMediaError.prototype.PERMISSION_DENIED;  /** 1 */

/**
 * @type {number}
 * @deprecated Removed from the standard and some browsers.
 * Read only.
 */
NavigatorUserMediaError.prototype.code;

/**
 * @type {string}
 * Read only.
 */
NavigatorUserMediaError.prototype.name;

/**
 * @type {?string}
 * Read only.
 */
NavigatorUserMediaError.prototype.message;

/**
 * @type {?string}
 * Read only.
 */
NavigatorUserMediaError.prototype.constraintName;

/**
 * @param {MediaStreamConstraints} constraints A MediaStreamConstraints object.
 * @param {function(!MediaStream)} successCallback
 *     A NavigatorUserMediaSuccessCallback function.
 * @param {function(!NavigatorUserMediaError)=} errorCallback A
 *     NavigatorUserMediaErrorCallback function.
 * @see http://dev.w3.org/2011/webrtc/editor/getusermedia.html
 * @see https://www.w3.org/TR/mediacapture-streams/
 * @return {undefined}
 */
Navigator.prototype.webkitGetUserMedia =
  function(constraints, successCallback, errorCallback) {};

/**
 * @param {string} type
 * @param {!Object} eventInitDict
 * @constructor
 */
function MediaStreamEvent(type, eventInitDict) {}

/**
 * @type {?MediaStream}
 * @const
 */
MediaStreamEvent.prototype.stream;

/**
 * @record
 * @see https://www.w3.org/TR/mediastream-recording/#dictdef-mediarecorderoptions
 */
function MediaRecorderOptions() {}

/** @type {(string|undefined)} */
MediaRecorderOptions.prototype.mimeType

/** @type {(number|undefined)} */
MediaRecorderOptions.prototype.audioBitsPerSecond

/** @type {(number|undefined)} */
MediaRecorderOptions.prototype.videoBitsPerSecond

/** @type {(number|undefined)} */
MediaRecorderOptions.prototype.bitsPerSecond

/**
 * @see https://www.w3.org/TR/mediastream-recording/#mediarecorder-api
 * @param {!MediaStream} stream
 * @param {MediaRecorderOptions=} options
 * @implements {EventTarget}
 * @constructor
 */
function MediaRecorder(stream, options) {}

/**
 * @override
 */
MediaRecorder.prototype.addEventListener = function(type, listener,
    opt_useCapture) {};

/**
 * @override
 */
MediaRecorder.prototype.removeEventListener = function(type, listener,
    opt_useCapture) {};

/**
 * @override
 * @return {boolean}
 */
MediaRecorder.prototype.dispatchEvent = function(evt) {};

/**
 * @type {!MediaStream}
 */
MediaRecorder.prototype.stream;

/**
 * @type {string}
 */
MediaRecorder.prototype.mimeType;

/**
 * @type {string}
 */
MediaRecorder.prototype.state;

/**
 * @type {(function(!Event)|undefined)}
 */
MediaRecorder.prototype.onstart;

/**
 * @type {(function(!Event)|undefined)}
 */
MediaRecorder.prototype.onstop;

/**
 * @type {(function(!Event)|undefined)}
 */
MediaRecorder.prototype.ondataavailable;

/**
 * @type {(function(!Event)|undefined)}
 */
MediaRecorder.prototype.onpause;

/**
 * @type {(function(!Event)|undefined)}
 */
MediaRecorder.prototype.onresume;

/**
 * @type {(function(!Event)|undefined)}
 */
MediaRecorder.prototype.onerror;

/**
 * @type {number}
 */
MediaRecorder.prototype.videoBitsPerSecond;

/**
 * @type {number}
 */
MediaRecorder.prototype.audioBitsPerSecond;

/**
 * @param {number=} timeslice
 */
MediaRecorder.prototype.start = function(timeslice) {};

/** @return {void} */
MediaRecorder.prototype.stop = function() {};

/** @return {void} */
MediaRecorder.prototype.pause = function() {};

/** @return {void} */
MediaRecorder.prototype.resume = function() {};

/** @return {void} */
MediaRecorder.prototype.requestData = function() {};

/**
 * @param {string} type
 * @return {boolean}
 */
MediaRecorder.isTypeSupported = function(type) {};

/**
 * @interface
 * @see https://w3c.github.io/mediacapture-image/##photosettings-section
 */
function PhotoSettings() {}

/**
 * @type {string}
 */
PhotoSettings.prototype.fillLightMode;

/**
 * @type {number}
 */
PhotoSettings.prototype.imageHeight;

/**
 * @type {number}
 */
PhotoSettings.prototype.imageWidth;

/**
 * @type {boolean}
 */
PhotoSettings.prototype.redEyeReduction;

/**
 * @interface
 * @see https://w3c.github.io/mediacapture-image/##photocapabilities-section
 */
function PhotoCapabilities() {}

/**
 * @type {string}
 * @const
 */
PhotoCapabilities.prototype.redEyeReduction;

/**
 * @type {!MediaSettingsRange}
 * @const
 */
PhotoCapabilities.prototype.imageHeight;

/**
 * @type {!MediaSettingsRange}
 * @const
 */
PhotoCapabilities.prototype.imageWidth;

/**
 * @type {!Array<!string>}
 * @const
 */
PhotoCapabilities.prototype.fillLightMode;

/**
 * @see https://w3c.github.io/mediacapture-image/
 * @param {!MediaStreamTrack} videoTrack
 * @constructor
 */
function ImageCapture(videoTrack) {}

/**
 * @param {!PhotoSettings=} photoSettings
 * @return {!Promise<!Blob>}
 */
ImageCapture.prototype.takePhoto = function(photoSettings) {};

/**
 * @return {!Promise<!PhotoCapabilities>}
 */
ImageCapture.prototype.getPhotoCapabilities = function() {};

/**
 * @return {!Promise<!ImageBitmap>}
 */
ImageCapture.prototype.grabFrame = function() {};

/**
 * @type {!MediaStreamTrack}
 * @const
 */
ImageCapture.prototype.track;

/**
 * @see https://www.w3.org/TR/webrtc/#rtctrackevent
 * @param {string} type
 * @param {!Object} eventInitDict
 * @constructor
 */
function RTCTrackEvent(type, eventInitDict) {}

/**
 * @type {?RTCRtpReceiver}
 * @const
 */
RTCTrackEvent.prototype.receiver;

/**
 * @type {?MediaStreamTrack}
 * @const
 */
RTCTrackEvent.prototype.track;

/**
 * @type {?Array<!MediaStream>}
 * @const
 */
RTCTrackEvent.prototype.streams;

/**
 * @type {?RTCRtpTransceiver}
 * @const
 */
RTCTrackEvent.prototype.transceiver;

/**
 * @typedef {string}
 * @see https://www.w3.org/TR/mediacapture-streams/#idl-def-MediaDeviceKind
 * In WebIDL this is an enum with values 'audioinput', 'audiooutput', and
 * 'videoinput', but there is no mechanism in Closure for describing a
 * specialization of the string type.
 */
var MediaDeviceKind;

/**
 * Possible values are "sendrecv", "sendonly", "recvonly", and "inactive".
 * @typedef {string}
 * @see https://www.w3.org/TR/webrtc/#dom-rtcrtptransceiverdirection
 */
var RTCRtpTransceiverDirection;

/**
 * @interface
 */
function MediaDeviceInfo() {}

/** @const {string} */
MediaDeviceInfo.prototype.deviceId;

/** @const {!MediaDeviceKind} */
MediaDeviceInfo.prototype.kind;

/** @const {string} */
MediaDeviceInfo.prototype.label;

/** @const {string} */
MediaDeviceInfo.prototype.groupId;

/**
 * @interface
 * @extends {EventTarget}
 * @see https://www.w3.org/TR/mediacapture-streams/#mediadevices
 */
function MediaDevices() {}

/**
 * @return {!Promise<!Array<!MediaDeviceInfo>>}
 */
MediaDevices.prototype.enumerateDevices = function() {};

/**
 * @see https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia
 * @param {!MediaStreamConstraints} constraints
 * @return {!Promise<!MediaStream>}
 */
MediaDevices.prototype.getUserMedia = function(constraints) {}

/**
 * @see https://w3c.github.io/mediacapture-main/#dom-mediadevices-getsupportedconstraints
 * @return {!MediaTrackSupportedConstraints}
 */
MediaDevices.prototype.getSupportedConstraints = function()  {}

/** @const {!MediaDevices} */
Navigator.prototype.mediaDevices;

/**
 * @typedef {string}
 * @see https://www.w3.org/TR/webrtc/#rtcsdptype
 * In WebIDL this is an enum with values 'offer', 'pranswer', and 'answer',
 * but there is no mechanism in Closure for describing a specialization of
 * the string type.
 */
var RTCSdpType;

/**
 * @param {!Object=} descriptionInitDict The RTCSessionDescriptionInit
 * dictionary.  This optional argument may have type
 * {type:RTCSdpType, sdp:string}, but neither of these keys are required to be
 * present, and other keys are ignored, so the closest Closure type is Object.
 * @constructor
 * @see https://www.w3.org/TR/webrtc/#rtcsessiondescription-class
 */
function RTCSessionDescription(descriptionInitDict) {}

/**
 * @type {?RTCSdpType}
 * @see https://www.w3.org/TR/webrtc/#dom-rtcsessiondescription-type
 */
RTCSessionDescription.prototype.type;

/**
 * @type {?string}
 * @see https://www.w3.org/TR/webrtc/#dom-rtcsessiondescription-sdp
 */
RTCSessionDescription.prototype.sdp;

/**
 * TODO(bemasc): Remove this definition once it is removed from the browser.
 * @param {string} label The label index (audio/video/data -> 0,1,2)
 * @param {string} sdp The ICE candidate in SDP text form
 * @constructor
 */
function IceCandidate(label, sdp) {}

/**
 * @return {string}
 */
IceCandidate.prototype.toSdp = function() {};

/**
 * @type {?string}
 */
IceCandidate.prototype.label;

/** @record */
function RTCIceCandidateInit() {};

/** @type {?string|undefined} */
RTCIceCandidateInit.prototype.candidate;

/** @type {(?string|undefined)} */
RTCIceCandidateInit.prototype.sdpMid;

/** @type {(?number|undefined)} */
RTCIceCandidateInit.prototype.sdpMLineIndex;

/** @type {(string|undefined)} */
RTCIceCandidateInit.prototype.usernameFragment;

/**
 * @param {!RTCIceCandidateInit=} candidateInitDict  The RTCIceCandidateInit dictionary.
 * @constructor
 * @see https://www.w3.org/TR/webrtc/#rtcicecandidate-interface
 */
function RTCIceCandidate(candidateInitDict) {}

/**
 * @type {?string}
 */
RTCIceCandidate.prototype.candidate;

/**
 * @type {?string}
 */
RTCIceCandidate.prototype.sdpMid;

/**
 * @type {?number}
 */
RTCIceCandidate.prototype.sdpMLineIndex;

/**
 * @typedef {{urls: string}|{urls: !Array<!string>}}
 * @private
 * @see https://www.w3.org/TR/webrtc/#rtciceserver-dictionary
 * This dictionary type also has an optional key {credential: ?string}.
 */
var RTCIceServerRecord_;

/**
 * @interface
 * @private
 */
function RTCIceServerInterface_() {}

/**
 * @type {string|!Array<!string>}
 */
RTCIceServerInterface_.prototype.urls;

/**
 * @type {?string}
 */
RTCIceServerInterface_.prototype.username;

/**
 * @type {?string}
 */
RTCIceServerInterface_.prototype.credential;

/**
 * This type, and several below it, are constructed as unions between records
 *
 * @typedef {RTCIceServerRecord_|RTCIceServerInterface_}
 * @private
 */
var RTCIceServer;

/**
 * @typedef {{iceServers: !Array<!RTCIceServer>}}
 * @private
 */
var RTCConfigurationRecord_;

/**
 * @interface
 * @private
 */
function RTCConfigurationInterface_() {}

/**
 * @type {!Array<!RTCIceServer>}
 */
RTCConfigurationInterface_.prototype.iceServers;

/**
 * @typedef {RTCConfigurationRecord_|RTCConfigurationInterface_}
 */
var RTCConfiguration;

/**
 * @typedef {function(!RTCSessionDescription)}
 */
var RTCSessionDescriptionCallback;

/**
 * @typedef {function(string)}
 */
var RTCPeerConnectionErrorCallback;

/**
 * @typedef {function()}
 */
var RTCVoidCallback;

/**
 * @typedef {string}
 */
var RTCSignalingState;

/**
 * @typedef {string}
 */
var RTCIceConnectionState;

/**
 * @typedef {string}
 */
var RTCIceGatheringState;

/**
 * @param {string} type
 * @param {!Object} eventInitDict
 * @constructor
 */
function RTCPeerConnectionIceEvent(type, eventInitDict) {}

/**
 * @type {RTCIceCandidate}
 * @const
 */
RTCPeerConnectionIceEvent.prototype.candidate;

// Note: The specification of RTCStats types is still under development.
// Declarations here will be updated and removed to follow the development of
// modern browsers, breaking compatibility with older versions as they become
// obsolete.
/**
 * @interface
 */
function RTCStatsReport() {}

/**
 * @type {Date}
 * @const
 */
RTCStatsReport.prototype.timestamp;

/**
 * @return {!Array<!string>}
 */
RTCStatsReport.prototype.names = function() {};

/**
 * @param {string} name
 * @return {string}
 */
RTCStatsReport.prototype.stat = function(name) {};

/**
 * @deprecated
 * @type {RTCStatsReport}
 * @const
 */
RTCStatsReport.prototype.local;

/**
 * @deprecated
 * @type {RTCStatsReport}
 * @const
 */
RTCStatsReport.prototype.remote;

/**
 * @type {string}
 * @const
 */
RTCStatsReport.prototype.type;

/**
 * @type {string}
 * @const
 */
RTCStatsReport.prototype.id;

// Note: Below are Map like methods supported by WebRTC statistics
// specification-compliant RTCStatsReport. Currently only implemented by
// Mozilla.
// See https://www.w3.org/TR/webrtc/#rtcstatsreport-object for definition.
/**
 * @param {function(this:SCOPE, Object)} callback
 * @param {SCOPE=} opt_thisObj The value of "this" inside callback function.
 * @template SCOPE
 * @readonly
 */
RTCStatsReport.prototype.forEach = function(callback, opt_thisObj) {};

/**
 * @param {string} key
 * @return {Object}
 * @readonly
 */
RTCStatsReport.prototype.get = function(key) {};

/**
 * @return {!IteratorIterable<string>}
 * @readonly
 */
RTCStatsReport.prototype.keys = function() {};

/**
 * TODO(bemasc): Remove this type once it is no longer in use.  It has already
 * been removed from the specification.
 * @typedef {RTCStatsReport}
 * @deprecated
 */
var RTCStatsElement;

/**
 * @interface
 */
function RTCStatsResponse() {}

/**
 * @return {!Array<!RTCStatsReport>}
 */
RTCStatsResponse.prototype.result = function() {};

/**
 * @typedef {function(!RTCStatsResponse, MediaStreamTrack=)}
 */
var RTCStatsCallback;

/**
 * This type is not yet standardized, so the properties here only represent
 * the current capabilities of libjingle (and hence Chromium).
 * TODO(bemasc): Add a link to the relevant standard once MediaConstraint has a
 * standard definition.
 *
 * @interface
 * @private
 */
function MediaConstraintSetInterface_() {}

/**
 * @type {?boolean}
 */
MediaConstraintSetInterface_.prototype.OfferToReceiveAudio;

/**
 * @type {?boolean}
 */
MediaConstraintSetInterface_.prototype.OfferToReceiveVideo;

/**
 * @type {?boolean}
 */
MediaConstraintSetInterface_.prototype.DtlsSrtpKeyAgreement;

/**
 * @type {?boolean}
 */
MediaConstraintSetInterface_.prototype.RtpDataChannels;

/**
 * TODO(bemasc): Make this type public once it is defined in a standard.
 *
 * @typedef {Object|MediaConstraintSetInterface_}
 * @private
 */
var MediaConstraintSet_;

/**
 * @interface
 * @private
 */
function MediaConstraintsInterface_() {}

/**
 * @type {?MediaConstraintSet_}
 */
MediaConstraintsInterface_.prototype.mandatory;

/**
 * @type {?Array<!MediaConstraintSet_>}
 */
MediaConstraintsInterface_.prototype.optional;

/**
 * This type is used extensively in
 * {@see http://dev.w3.org/2011/webrtc/editor/webrtc.html} but is not yet
 * defined.
 *
 * @typedef {Object|MediaConstraintsInterface_}
 */
var MediaConstraints;

/**
 * @interface
 * @extends {EventTarget}
 */
function RTCDataChannel() {}

/**
 * @type {string}
 * @const
 */
RTCDataChannel.prototype.label;

/**
 * @type {boolean}
 * @const
 */
RTCDataChannel.prototype.reliable;

/**
 * An enumerated string type (RTCDataChannelState) with values:
 * "connecting", "open", "closing", and "closed".
 * @type {string}
 * Read only.
 */
RTCDataChannel.prototype.readyState;

/**
 * @type {number}
 * Read only.
 */
RTCDataChannel.prototype.bufferedAmount;

/**
 * @type {?function(!Event)}
 */
RTCDataChannel.prototype.onopen;

/**
 * @type {?function(!Event)}
 */
RTCDataChannel.prototype.onerror;

/**
 * @type {?function(!Event)}
 */
RTCDataChannel.prototype.onclose;

RTCDataChannel.prototype.close = function() {};

/**
 * @type {?function(!MessageEvent<*>)}
 */
RTCDataChannel.prototype.onmessage;

/**
 * @type {string}
 */
RTCDataChannel.prototype.binaryType;

/**
 * @param {string|!Blob|!ArrayBuffer|!ArrayBufferView} data
 * @return {undefined}
 */
RTCDataChannel.prototype.send = function(data) {};

/**
 * @constructor
 * @extends {Event}
 * @private
 */
function RTCDataChannelEvent() {}

/**
 * @type {!RTCDataChannel}
 * Read only.
 */
RTCDataChannelEvent.prototype.channel;

/**
 * @typedef {{reliable: boolean}}
 */
var RTCDataChannelInitRecord_;

/**
 * @interface
 * @private
 */
function RTCDataChannelInitInterface_() {}

/**
 * @type {boolean}
 */
RTCDataChannelInitInterface_.prototype.reliable;

/**
 * @typedef {Object}
 * @property {boolean=} [ordered=true]
 * @property {number=} maxPacketLifeTime
 * @property {number=} maxRetransmits
 * @property {string=} [protocol=""]
 * @property {boolean=} [negotiated=false]
 * @property {number=} id
 * @property {string=} [priority='low']
 * see https://www.w3.org/TR/webrtc/#dom-rtcdatachannelinit for documentation
 * Type inconsistencies due to Closure limitations:
 * maxPacketLifeTime should be UnsignedShort
 * maxRetransmits should be UnsignedShort
 * protocol should be USVString
 * id should be UnsignedShort
 * In WebIDL priority is an enum with values 'very-low', 'low',
 * 'medium' and 'high', but there is no mechanism in Closure for describing
 * a specialization of the string type.
 */
var RTCDataChannelInitDictionary_;

/**
 * @typedef {RTCDataChannelInitInterface_|RTCDataChannelInitRecord_|RTCDataChannelInitDictionary_}
 */
var RTCDataChannelInit;

/**
 * @typedef {{expires: number}}
 */
var RTCCertificate;

/**
 * @param {RTCConfiguration} configuration
 * @param {!MediaConstraints=} constraints
 * @constructor
 * @implements {EventTarget}
 */
function RTCPeerConnection(configuration, constraints) {}

/**
 * @param {Object} keygenAlgorithm
 * @return {Promise<RTCCertificate>}
 */
RTCPeerConnection.generateCertificate = function (keygenAlgorithm) {};

/**
 * @override
 */
RTCPeerConnection.prototype.addEventListener = function(
    type, listener, opt_useCapture) {};

/**
 * @override
 */
RTCPeerConnection.prototype.removeEventListener = function(
    type, listener, opt_useCapture) {};

/**
 * @override
 * @return {boolean}
 */
RTCPeerConnection.prototype.dispatchEvent = function(evt) {};

// NB: Until closure annotations support overloading, many of the following
// functions take odd unions of parameter types.  This is to support the various
// api differences between browsers.  Generally, returning a promise means you
// don't take callback function parameters and draw any further parameters
// forward, and vice versa.

/**
 * @param {(!RTCSessionDescriptionCallback|!MediaConstraints)=}
 *    successCallbackOrConstraints
 * @param {!RTCPeerConnectionErrorCallback=} errorCallback
 * @param {!MediaConstraints=} constraints
 * @return {!Promise<!RTCSessionDescription>|undefined}
 */
RTCPeerConnection.prototype.createOffer = function(successCallbackOrConstraints,
    errorCallback, constraints) {};

/**
 * @param {(!RTCSessionDescriptionCallback|!MediaConstraints)=}
 *    successCallbackOrConstraints
 * @param {!RTCPeerConnectionErrorCallback=} errorCallback
 * @param {!MediaConstraints=} constraints
 * @return {!Promise<!RTCSessionDescription>|undefined}
 */
RTCPeerConnection.prototype.createAnswer =
    function(successCallbackOrConstraints, errorCallback, constraints) {};

/**
 * @param {!RTCSessionDescription} description
 * @param {!RTCVoidCallback=} successCallback
 * @param {!RTCPeerConnectionErrorCallback=} errorCallback
 * @return {!Promise<!RTCSessionDescription>}
 */
RTCPeerConnection.prototype.setLocalDescription = function(description,
    successCallback, errorCallback) {};

/**
 * @param {!RTCSessionDescription} description
 * @param {!RTCVoidCallback=} successCallback
 * @param {!RTCPeerConnectionErrorCallback=} errorCallback
 * @return {!Promise<!RTCSessionDescription>}
 */
RTCPeerConnection.prototype.setRemoteDescription = function(description,
    successCallback, errorCallback) {};

/**
 * @type {?RTCSessionDescription}
 * Read only.
 */
RTCPeerConnection.prototype.localDescription;

/**
 * @type {?RTCSessionDescription}
 * Read only.
 */
RTCPeerConnection.prototype.remoteDescription;

/**
 * @type {RTCSignalingState}
 * Read only.
 */
RTCPeerConnection.prototype.signalingState;

/**
 * @param {?RTCConfiguration=} configuration
 * @param {?MediaConstraints=} constraints
 * @return {undefined}
 */
RTCPeerConnection.prototype.updateIce = function(configuration, constraints) {};

/**
 * Void in Chrome for now, a promise that you can then/catch in Firefox.
 * @param {!RTCIceCandidate} candidate
 * @param {!RTCVoidCallback=} successCallback
 * @param {!function(DOMException)=} errorCallback
 * @return {!Promise|undefined}
 */
RTCPeerConnection.prototype.addIceCandidate = function(candidate, successCallback, errorCallback) {};

/**
 * @type {!RTCIceGatheringState}
 * Read only.
 */
RTCPeerConnection.prototype.iceGatheringState;

/**
 * @type {!RTCIceConnectionState}
 * Read only.
 */
RTCPeerConnection.prototype.iceConnectionState;

/**
 * @return {!Array<!MediaStream>}
 */
RTCPeerConnection.prototype.getLocalStreams = function() {};

/**
 * @return {!Array<!MediaStream>}
 */
RTCPeerConnection.prototype.getRemoteStreams = function() {};

/**
 * @param {string} streamId
 * @return {MediaStream}
 */
RTCPeerConnection.prototype.getStreamById = function(streamId) {};

/**
 * @return {!Array<!RTCRtpSender>}
 */
RTCPeerConnection.prototype.getSenders = function() {};

/**
 * @return {!Array<!RTCRtpReceiver>}
 */
RTCPeerConnection.prototype.getReceivers = function() {};

/**
 * @param {?string} label
 * @param {RTCDataChannelInit=} dataChannelDict
 * @return {!RTCDataChannel}
 */
RTCPeerConnection.prototype.createDataChannel =
    function(label, dataChannelDict) {};
/**
 * @param {!MediaStream} stream
 * @param {!MediaConstraints=} constraints
 * @return {undefined}
 */
RTCPeerConnection.prototype.addStream = function(stream, constraints) {};

/**
 * @param {!MediaStream} stream
 * @return {undefined}
 */
RTCPeerConnection.prototype.removeStream = function(stream) {};

/**
 * @param {!MediaStreamTrack} track
 * @param {!MediaStream} stream
 * @param {...MediaStream} var_args Additional streams.
 * @return {!RTCRtpSender}
 */
RTCPeerConnection.prototype.addTrack = function(track, stream, var_args) {};

/**
 * @param {!MediaStreamTrack|string} trackOrKind
 * @param {?RTCRtpTransceiverInit=} init
 * @return {!RTCRtpTransceiver}
 */
RTCPeerConnection.prototype.addTransceiver = function(trackOrKind, init) {};

/**
 * Returns the list of transceivers are currently attached to this peer.
 *
 * @return {!Array<!RTCRtpTransceiver>}
 */
RTCPeerConnection.prototype.getTransceivers = function() {};

/**
 * @return {!RTCConfiguration}
 */
RTCPeerConnection.prototype.getConfiguration = function() {};

/**
 * @param {!RTCConfiguration} configuration
 * @return {undefined}
 */
RTCPeerConnection.prototype.setConfiguration = function(configuration) {};

/**
 * @param {!RTCRtpSender} sender
 * @return {undefined}
 */
RTCPeerConnection.prototype.removeTrack = function(sender) {};

// TODO(bemasc): Add identity provider stuff once implementations exist

// TODO(rjogrady): Per w3c spec, getStats() should always return a Promise.
// Remove RTCStatsReport from the return value once Firefox supports that.
/**
 * Firefox' getstats is synchronous and returns a much simpler
 * {!RTCStatsReport} Map-like object.
 * @param {!RTCStatsCallback=} successCallback
 * @param {MediaStreamTrack=} selector
 * @return {undefined|!RTCStatsReport|!Promise<!RTCStatsReport>}
 */
RTCPeerConnection.prototype.getStats = function(successCallback, selector) {};

RTCPeerConnection.prototype.close = function() {};

/**
 * @type {?function(!Event)}
 */
RTCPeerConnection.prototype.onnegotiationneeded;

/**
 * @type {?function(!RTCPeerConnectionIceEvent)}
 */
RTCPeerConnection.prototype.onicecandidate;

/**
 * @type {?function(!Event)}
 */
RTCPeerConnection.prototype.onsignalingstatechange;

/**
 * @type {?function(!MediaStreamEvent)}
 */
RTCPeerConnection.prototype.onaddstream;

/**
 * @type {?function(!RTCTrackEvent)}
 */
RTCPeerConnection.prototype.ontrack;

/**
 * @type {?function(!MediaStreamEvent)}
 */
RTCPeerConnection.prototype.onremovestream;

/**
 * @type {?function(!Event)}
 */
RTCPeerConnection.prototype.oniceconnectionstatechange;

/**
 * @type {?function(!RTCDataChannelEvent)}
 */
RTCPeerConnection.prototype.ondatachannel;

/**
 * @const
 */
var webkitRTCPeerConnection = RTCPeerConnection;


text:
  Souain-Perthes-lès-Hurlus est
       un village
       géographiquement positionné dans le département de Marne en Champagne-Ardenne. Elle comptait 202 habitants en 2008.

La commune offre quelques  équipements sportifs, elle dispose, entre autres, de deux terrains de sport.

Le nombre de logements, à Souain-Perthes-lès-Hurlus, se décomposait en 2011 en zero appartements et 83 maisons soit
 un marché relativement équilibré.

À proximité de Souain-Perthes-lès-Hurlus sont situées les villes de
Jonchery-sur-Suippe à 5 km, 167 habitants,
Aubérive localisée à 9 km, 194 habitants,
Laval-sur-Tourbe située à 11 km, 47 habitants,
Vaudesincourt à 10 km, 116 habitants,
Sommepy-Tahure à 7 km, 609 habitants,
Saint-Souplet-sur-Py localisée à 7 km, 147 habitants,
 entre autres. De plus, Souain-Perthes-lès-Hurlus est située à seulement 28 km de Châlons-en-Champagne.

Si vous envisagez de demenager à Souain-Perthes-lès-Hurlus, vous pourrez facilement trouver une maison à acheter.


text:
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

namespace ExcelLibrary.BinaryFileFormat
{
	public partial class OBJ : Record
	{
        public List<SubRecord> SubRecords = new List<SubRecord>();

        public override void Decode()
        {
            MemoryStream stream = new MemoryStream(Data);
            SubRecords.Clear();
            while (stream.Position < Size)
            {
                SubRecord subRecord = SubRecord.Read(stream);
                subRecord.Decode();
                SubRecords.Add(subRecord);
            }
        }

        public override void Encode()
        {
            MemoryStream stream = new MemoryStream();
            BinaryWriter writer = new BinaryWriter(stream);
            foreach (SubRecord subRecord in SubRecords)
            {
                subRecord.Encode();
                subRecord.Write(writer);
            }
            this.Data = stream.ToArray();
            this.Size = (UInt16)Data.Length;
        }

	}
}


text:
namespace user_prefs {

PrefRegistrySyncable::PrefRegistrySyncable() {
}

PrefRegistrySyncable::~PrefRegistrySyncable() {
}

void PrefRegistrySyncable::SetSyncableRegistrationCallback(
    const SyncableRegistrationCallback& cb) {
  callback_ = cb;
}

void PrefRegistrySyncable::OnPrefRegistered(const std::string& path,
                                            base::Value* default_value,
                                            uint32_t flags) {
  // Tests that |flags| does not contain both SYNCABLE_PREF and
  // SYNCABLE_PRIORITY_PREF flags at the same time.
  DCHECK(!(flags & PrefRegistrySyncable::SYNCABLE_PREF) ||
         !(flags & PrefRegistrySyncable::SYNCABLE_PRIORITY_PREF));

  if (flags & PrefRegistrySyncable::SYNCABLE_PREF ||
      flags & PrefRegistrySyncable::SYNCABLE_PRIORITY_PREF) {
    if (!callback_.is_null())
      callback_.Run(path, flags);
  }
}

scoped_refptr<PrefRegistrySyncable> PrefRegistrySyncable::ForkForIncognito() {
  // TODO(joi): We can directly reuse the same PrefRegistry once
  // PrefService no longer registers for callbacks on registration and
  // unregistration.
  scoped_refptr<PrefRegistrySyncable> registry(new PrefRegistrySyncable());
  registry->defaults_ = defaults_;
  return registry;
}

}  // namespace user_prefs


text:
import scala.collection.mutable
import scala.collection.mutable.ArrayBuffer

import TestEase._

object ResultGraphTest {
  def runTests() = {
    TestEase.inTest()

    val graphTester = new GraphTest(ResultGraph.basic)
    val graphs = graphTester.go()

    val graphsDir = "src/main/resources"
    val invalidFilename = "%s/invalid.graph".format(graphsDir)

    val invalidGraph =
      ResultGraph.loadFromFile[BaseNode, BaseEdge](invalidFilename)

    def testValidation() = {
      graphs("small").validate()
      exnClass("ValidationException") {
        invalidGraph.validate()
      }
    }

    testValidation()
  }

  def main(args:Array[String] = Array()) = {
    runTests()
    println("ResultGraphTest: PASSED")
  }
}


text:
package com.github.noxan.aves.util;

public class Tuple<A, B> {
    private A first;
    private B second;

    public Tuple(A first, B second) {
        setFirst(first);
        setSecond(second);
    }

    public void setFirst(A first) {
        this.first = first;
    }

    public A getFirst() {
        return first;
    }

    public void setSecond(B second) {
        this.second = second;
    }

    public B getSecond() {
        return second;
    }

    @Override
    public String toString() {
        return getClass().getName() + "(" + getFirst() + ", " + getSecond() + ")";
    }
}


text:
<!DOCTYPE html>
<meta charset="utf-8">
<title>CSS Flexbox Test: gap - vertical with RL vertical writing mode</title>
<link rel="author" title="Adam Argyle" href="mailto:argyle@google.com">

Test passes if there is a green vertical line between boxes.


text:
zeit.cms.declare_namespace('zeit.edit');

zeit.edit.makeJSONRequest = function(
    url, json, target_component, options) {
    return zeit.cms.with_lock(
        zeit.edit._locked_makeJSONRequest,
        url, json, target_component, options);
};

zeit.edit._locked_makeJSONRequest = function(
    url, json, target_component, options) {

    if (isUndefinedOrNull(target_component)) {
        target_component = zeit.edit.editor;
    }
    zeit.edit.editor.busy_until_reload_of(target_component);
    options = MochiKit.Base.setdefault(options, {
        method: 'GET'
    });

    var q_index = url.indexOf('?');
    if (q_index >= 0) {
        json = MochiKit.Base.setdefault(
            json,
            MochiKit.Base.parseQueryString(url.slice(q_index + 1)));
        url = url.slice(0, q_index);
    }

    if (!isUndefinedOrNull(json)) {
        options.method = 'POST';
        json = MochiKit.Base.serializeJSON(json);
    }
    var d = MochiKit.Async.doXHR(url, {
        method: options.method,
        sendContent: json});
    d.addCallbacks(function(result) {
        var result_obj = null;
        try {
            result_obj = MochiKit.Async.evalJSONRequest(result);
        } catch (e) {
            if (! e instanceof SyntaxError) {
                throw e;
            }
        }
        var immediate_actions = [];
        if (!isNull(result_obj)) {
            var signals = result_obj['signals'] || [];
            forEach(signals, function(signal) {
                if (isNull(signal.when)) {
                    immediate_actions.push(signal);
                } else {
                    log("Connecting "+ [target_component.__name__, signal.when, signal.name]);
                    (function() {
                        var ident = MochiKit.Signal.connect(
                            target_component, signal.when, function() {
                            log("Signalling (when) "+ [target_component.__name__, signal.when, signal.name]);
                            MochiKit.Signal.disconnect(ident);
                            MochiKit.Signal.signal.apply(
                                this,
                                extend(
                                    [target_component, signal.name],
                                    signal.args));
                        });
                    }());
                }
            });
        }
        if (immediate_actions.length) {
            immediate_actions.reverse();
            while(immediate_actions.length) {
                var signal = immediate_actions.pop();
                log("Signalling (immediate) "+ [target_component.__name__, signal.name, signal.args]);
                MochiKit.Signal.signal.apply(
                    this,
                    extend([target_component, signal.name], signal.args));
            }
        }
        return result;
    },
    function(error) {
        zeit.edit.handle_json_errors(error);
        MochiKit.Signal.signal(target_component, 'reload');
        return error;
    });
    return d;
};

zeit.edit.handle_json_errors = function(error) {
    zeit.cms.log_error(error);
    if (!isUndefinedOrNull(error.req)) {
        var div = DIV();
        div.innerHTML = error.req.responseText;
        var message_node = MochiKit.DOM.getFirstElementByTagAndClassName(
            'pre', null, div);
        var message;
        if (isNull(message_node)) {
            message = error.req.responseText;
        } else {
            message = message_node.textContent;
        }
        alert(message);
    }
    return error;
};


text:
package test

var V int

var NewError1 int

// invalid func comment
func F() {
}

// invalid func comment2
func F2() {
}