API Docs for:
Show:

Modules.AnchorTrigger Class

Extends Modules._DOMModule
Defined in: development/modules/anchor/js/anchor.js:24
Module: Modules

AnchorTrigger module

Constructor

Modules.AnchorTrigger

()

Defined in development/modules/anchor/js/anchor.js:24

Methods

$data

(
  • key
)
Any | Null

Inherited from Modules._DOMModule: development/modules/__base/dommodule.js:113

Takes a key and returns either the value of a matching data- attribute or null if no data- attribute is set. Works only on the $root element

Parameters:

  • key String

    Key of the data- attribute to get

Returns:

Any | Null:

The value or null

Example:

import DOMModule from './modules/__base/dommodule';

class MyClass extends DOMModule {
    render() {
        const urlVal = this.$data('url') || '/default/url';
    }
}

$findChilds

(
  • selector
)
JQuery

Inherited from Modules._DOMModule: development/modules/__base/dommodule.js:69

Takes a CSS style selector and returns all elements under the root node of the widget which match the selector as jQuery collection

Parameters:

  • selector String

    Selector to match elements against

Returns:

JQuery:

A jQuery collection of matched elements

Example:

import DOMModule from './modules/__base/dommodule';

class MyClass extends DOMModule {
    render() {
        this.$buttons = this.$findChilds('button');
    }
}

$findParent

(
  • [selector]
)
JQuery

Inherited from Modules._DOMModule: development/modules/__base/dommodule.js:90

Takes a CSS style selector and returns the closes parent element of the root element of the widget that matches the selector. If no selector is specified, returns the immediate parent element of the root element.

Parameters:

  • [selector] String optional

    Selector to match elements against

Returns:

JQuery:

A jQuery collection of matched elements

Example:

import DOMModule from './modules/__base/dommodule';

class MyClass extends DOMModule {
    render() {
        this.$rootContainer = this.$findParent('div');
    }
}

$raw

(
  • index
)
DOMNode

Inherited from Modules._DOMModule: development/modules/__base/dommodule.js:134

Takes an zero based index and returns the raw DOMNode from the underlying jQuery collection on the given index. If the index is higher than the length of the collection, returns the last element of the collection. If it is omitted, returns the first element of the collection. Works only on the $root element

Parameters:

  • index Integer | Any

    Index of the raw DOMNode you want to get

Returns:

DOMNode:

The node on the given position

Example:

import DOMModule from './modules/__base/dommodule';

let items = new DOMModule('li'); // get all <li> elements as $rootNode

items.$raw(); // -> first <li>, equivalent to items.$raw(0)
items.$raw(4); // -> fourth or last <li>, depending on number of elements

_updateHash

(
  • hash
)
Undefined private

Defined in development/modules/anchor/js/anchor.js:123

Updates the hash part of the current URL of the browser

Parameters:

  • hash String

    The new location.hash value

Returns:

Undefined:

Nothing

addObserver

(
  • x
  • [m = 'update']
)
This

Inherited from Mixins.Observable: development/js/mixins/observable.js:53

Adds a observer object to the observable

Parameters:

  • x Object

    The object to register as observer

  • [m = 'update'] Function | String optional

    Function or method to use as handler

Returns:

This:

The observable instance

Example:

import Observable from './mixins/observable';

const logger = {
    update(message) {
        console.log(message);
    }
}

const MyClass = Observable(class {
    constructor() {
        this.addObserver(logger);
    }
});
import Observable from './mixins/observable';

const logger = {
    log(message) {
        console.log(message);
    }
}

const MyClass = Observable(class {
    constructor() {
        this.addObserver(logger, 'log');
    }
});

addState

(
  • state
)
This

Inherited from Mixins.FSM: development/js/mixins/fsm.js:21

Allows to add a new state (see example for more info)

Parameters:

  • state Object

    The new state

Returns:

This:

The instance

Example:

import FSM from './mixins/fsm';

const MyClass = FSM(class {
    constructor() {
        // New states MyClass can be in are added
        this.addState({
                name: 'init',
                events: {next: 'after'}
            }).
            addState({
                name: 'after',
                events: {next: 'last', prev: 'init'}
            }).
            addState({
                name: 'last',
                events: {prev: 'after'}
            });
    }
});

addStates

(
  • states
)
This

Inherited from Mixins.FSM: development/js/mixins/fsm.js:57

Allows to add an array of new states all at once

Parameters:

  • states Array

    The new states

Returns:

This:

The instance

Example:

import FSM from './mixins/fsm';

const MyStates = [
    {name: 'init', events: {next: 'after'}},
    {name: 'after', events: {next: 'last', prev: 'init'}},
    {name: 'last', events: {prev: 'after'}}
];

const MyClass = FSM(class {
    constructor() {
        // New states MyClass can be in are added
        this.addStates(MyStates);
    }
});

consume

(
  • eventName
)
This

Inherited from Mixins.FSM: development/js/mixins/fsm.js:148

Transitions from the current state to the state specified by the given name of event to consume.

Parameters:

  • eventName String

    Name of the event to consume

Returns:

This:

The instance

Example:

import FSM from './mixins/fsm';

const MyStates = [
    {name: 'init', events: {next: 'after'}},
    {name: 'after', events: {next: 'last', prev: 'init'}},
    {name: 'last', events: {prev: 'after'}}
];

const MyClass = FSM(class {
    constructor() {
        // New states MyClass can be in are added
        this.addStates(MyStates);
    }
});

let myInstance = new MyClass();
myInstance.getState(); // -> 'init'

myInstance.consume('next').consume('next').getState(); // -> 'last'

destroy

() Undefined

Inherited from Modules._BaseModule but overwritten in development/modules/__base/dommodule.js:43

Destroys the instance, releases all attached eventlisteners and removes all observers and states. Also removes the associated HTMLElement from the DOM

Returns:

Undefined:

Nothing

destroyObservers

() Undefined

Inherited from Mixins.Observable: development/js/mixins/observable.js:166

Destroys the observable, unregisters all observers

Returns:

Undefined:

Nothing

Example:

import Observable from './mixins/observable';

const logger = {
    update(message) {
        console.log(message);
    }
}

const MyClass = Observable(class {
    constructor() {
        this.addObserver(logger);
    }
});

let myInstance = new MyClass();
myInstance.notifyObservers('Sending a message');
// logs "Sending a message"

myInstance.destroyObservers();

myInstance.notifyObservers('Sending another message');
// nothing happens

destroyStates

() Undefined

Inherited from Mixins.FSM: development/js/mixins/fsm.js:184

Destroys all states associated with the FSM

Returns:

Undefined:

Nothing

Example:

import FSM from './mixins/fsm';

const MyStates = [
    {name: 'init', events: {next: 'after'}},
    {name: 'after', events: {next: 'last', prev: 'init'}},
    {name: 'last', events: {prev: 'after'}}
];

const MyClass = FSM(class {
    constructor() {
        // New states MyClass can be in are added
        this.addStates(MyStates);
    }
});

let myInstance = new MyClass();
myInstance.destroyStates();

findAll

(
  • selector
)
Array static

Defined in development/modules/anchor/js/anchor.js:62

Finds and initializes all Accordions on a page at once

Parameters:

  • selector String

    CSS selector to match nodes against

Returns:

Array:

A list of instances

Example:

import AnchorTrigger from './modules/anchor/js/anchor';

AnchorTrigger.findAll('[data-widget=AnchorTrigger]');

getState

() String | Null

Inherited from Mixins.FSM: development/js/mixins/fsm.js:85

Returns the name of the current state or null if no state is set

Returns:

String | Null:

Name of the current state or null

Example:

import FSM from './mixins/fsm';

const MyStates = [
    {name: 'init', events: {next: 'after'}},
    {name: 'after', events: {next: 'last', prev: 'init'}},
    {name: 'last', events: {prev: 'after'}}
];

const MyClass = FSM(class {
    constructor() {
        // New states MyClass can be in are added
        this.addStates(MyStates);
    }
});

let myInstance = new MyClass();
myInstance.getState(); // -> 'init'

hasObserver

(
  • x
  • [m = 'update']
)
Boolean

Inherited from Mixins.Observable: development/js/mixins/observable.js:19

Allows to test if a object is registered as a observer

Parameters:

  • x Object

    The object to check against

  • [m = 'update'] Function | String optional

    The function or method name to check

Returns:

Boolean:

True if registered, false if not

Example:

import Observable from './mixins/observable';

const logger = {
    log(message) {
        console.log(message);
    }
}

const MyClass = Observable(class {
    constructor() {
        this.addObserver(logger, 'log');
    }
});

let myInstance = new MyClass();
myInstance.hasObserver(logger, 'log');
// -> true

notifyObservers

(
  • x
  • [m = 'update']
)
This

Inherited from Mixins.Observable: development/js/mixins/observable.js:132

Notifies all registered observers with data

Parameters:

  • x Object

    The object to register as observer

  • [m = 'update'] Function | String optional

    Function or method to use as handler

Returns:

This:

The observable instance

Example:

import Observable from './mixins/observable';

const logger = {
    update(message) {
        console.log(message);
    }
}

const MyClass = Observable(class {
    constructor() {
        this.addObserver(logger);
    }
});

let myInstance = new MyClass();
myInstance.notifyObservers('Sending a message');
// logs "Sending a message"

of

(
  • node
)
AnchorTrigger static

Defined in development/modules/anchor/js/anchor.js:44

Creates a new AnchorTrigger instance without the "new" keyword but does not initialize it

Parameters:

  • node Node | String | Configs

    Node, CSS selector or configuration object

Returns:

AnchorTrigger:

A new instance

Example:

import AnchorTrigger from './modules/anchor/js/anchor';

const myTrigger = AnchorTrigger.of('[data-widget=AnchorTrigger]');
myTrigger.render().startUp();

offBlur

(
  • [selector]
  • handler
)
This

Inherited from Modules._DOMModule: development/modules/__base/dommodule.js:434

Opposite of the onBlur method

Parameters:

  • [selector] String optional

    Selector to match elements against

  • handler String | Function

    Eventhandler function or method name

Returns:

This:

The instance

offChange

(
  • [selector]
  • handler
)
This

Inherited from Modules._DOMModule: development/modules/__base/dommodule.js:354

Opposite of the onChange method

Parameters:

  • [selector] String optional

    Selector to match elements against

  • handler String | Function

    Eventhandler function or method name

Returns:

This:

The instance

offClick

(
  • [selector]
  • handler
)
This

Inherited from Modules._DOMModule: development/modules/__base/dommodule.js:314

Opposite of the onClick method

Parameters:

  • [selector] String optional

    Selector to match elements against

  • handler String | Function

    Eventhandler function or method name

Returns:

This:

The instance

offFocus

(
  • [selector]
  • handler
)
This

Inherited from Modules._DOMModule: development/modules/__base/dommodule.js:394

Opposite of the onFocus method

Parameters:

  • [selector] String optional

    Selector to match elements against

  • handler String | Function

    Eventhandler function or method name

Returns:

This:

The instance

offInput

(
  • [selector]
  • handler
)
This

Inherited from Modules._DOMModule: development/modules/__base/dommodule.js:475

Opposite of the onInput method

Parameters:

  • [selector] String optional

    Selector to match elements against

  • handler String | Function

    Eventhandler function or method name

Returns:

This:

The instance

offMove

(
  • [selector]
  • handler
)
This

Inherited from Modules._DOMModule: development/modules/__base/dommodule.js:233

Opposite of the onMove method

Parameters:

  • [selector] String optional

    Selector to match elements against

  • handler String | Function

    Eventhandler function or method name

Returns:

This:

The instance

offPress

(
  • [selector]
  • handler
)
This

Inherited from Modules._DOMModule: development/modules/__base/dommodule.js:192

Opposite of the onPress method

Parameters:

  • [selector] String optional

    Selector to match elements against

  • handler String | Function

    Eventhandler function or method name

Returns:

This:

The instance

offRelease

(
  • [selector]
  • handler
)
This

Inherited from Modules._DOMModule: development/modules/__base/dommodule.js:274

Opposite of the onRelease method

Parameters:

  • [selector] String optional

    Selector to match elements against

  • handler String | Function

    Eventhandler function or method name

Returns:

This:

The instance

offResize

(
  • [selector]
  • fn
)
This

Inherited from Modules._DOMModule: development/modules/__base/dommodule.js:601

Opposite of the onResize method

Parameters:

  • [selector] String optional

    Selector to match elements against

  • fn String | Function

    Eventhandler function or method name

Returns:

This:

The instance

offSubmit

(
  • [selector]
  • handler
)
This

Inherited from Modules._DOMModule: development/modules/__base/dommodule.js:557

Opposite of the onSubmit method

Parameters:

  • [selector] String optional

    Selector to match elements against

  • handler String | Function

    Eventhandler function or method name

Returns:

This:

The instance

offTransitionEnd

(
  • [selector]
  • handler
)
This

Inherited from Modules._DOMModule: development/modules/__base/dommodule.js:517

Opposite of the onTransitionEnd method

Parameters:

  • [selector] String optional

    Selector to match elements against

  • handler String | Function

    Eventhandler function or method name

Returns:

This:

The instance

onBlur

(
  • [selector]
  • handler
)
This

Inherited from Modules._DOMModule: development/modules/__base/dommodule.js:406

Takes a CSS style selector and a function or methodname and registers the function or method as eventhandler for all child elements of the root element which match the selector when the blur event occurs. If the selector is omitted and only a function/methodname is given, registers the handler on the root element.

Parameters:

  • [selector] String optional

    Selector to match elements against

  • handler String | Function

    Eventhandler function or method name

Returns:

This:

The instance

Example:

import DOMModule from './modules/__base/dommodule';

class MyClass extends DOMModule {
    render() {
        this.onBlur('input[name=MyInput]', 'blurHandle');
    }
    blurHandle(event) {
        // ... your code ...
    }
}

onChange

(
  • [selector]
  • handler
)
This

Inherited from Modules._DOMModule: development/modules/__base/dommodule.js:326

Takes a CSS style selector and a function or methodname and registers the function or method as eventhandler for all child elements of the root element which match the selector when the change event occurs. If the selector is omitted and only a function/methodname is given, registers the handler on the root element.

Parameters:

  • [selector] String optional

    Selector to match elements against

  • handler String | Function

    Eventhandler function or method name

Returns:

This:

The instance

Example:

import DOMModule from './modules/__base/dommodule';

class MyClass extends DOMModule {
    render() {
        this.onChange('button', 'changeHandle');
    }
    changeHandle(event) {
        // ... your code ...
    }
}

onClick

(
  • [selector]
  • handler
)
This

Inherited from Modules._DOMModule: development/modules/__base/dommodule.js:286

Takes a CSS style selector and a function or methodname and registers the function or method as eventhandler for all child elements of the root element which match the selector when the click event occurs. If the selector is omitted and only a function/methodname is given, registers the handler on the root element.

Parameters:

  • [selector] String optional

    Selector to match elements against

  • handler String | Function

    Eventhandler function or method name

Returns:

This:

The instance

Example:

import DOMModule from './modules/__base/dommodule';

class MyClass extends DOMModule {
    render() {
        this.onClick('button', 'clickHandle');
    }
    clickHandle(event) {
        // ... your code ...
    }
}

onFocus

(
  • [selector]
  • handler
)
This

Inherited from Modules._DOMModule: development/modules/__base/dommodule.js:366

Takes a CSS style selector and a function or methodname and registers the function or method as eventhandler for all child elements of the root element which match the selector when the focus event occurs. If the selector is omitted and only a function/methodname is given, registers the handler on the root element.

Parameters:

  • [selector] String optional

    Selector to match elements against

  • handler String | Function

    Eventhandler function or method name

Returns:

This:

The instance

Example:

import DOMModule from './modules/__base/dommodule';

class MyClass extends DOMModule {
    render() {
        this.onFocus('input[name=MyInput]', 'focusHandle');
    }
    focusHandle(event) {
        // ... your code ...
    }
}

onInput

(
  • [selector]
  • handler
)
This

Inherited from Modules._DOMModule: development/modules/__base/dommodule.js:446

Takes a CSS style selector and a function or methodname and registers the function or method as eventhandler for all child elements of the root element which match the selector when either the keyup/input event occurs. If the selector is omitted and only a function/methodname is given, registers the handler on the root element.

Parameters:

  • [selector] String optional

    Selector to match elements against

  • handler String | Function

    Eventhandler function or method name

Returns:

This:

The instance

Example:

import DOMModule from './modules/__base/dommodule';

class MyClass extends DOMModule {
    render() {
        this.onInput('input[name=MyInput]', 'inputHandle');
    }
    inputHandle(event) {
        // ... your code ...
    }
}

onMove

(
  • [selector]
  • handler
)
This

Inherited from Modules._DOMModule: development/modules/__base/dommodule.js:204

Takes a CSS style selector and a function or methodname and registers the function or method as eventhandler for all child elements of the root element which match the selector when either the mousemove/touchmove/pointermove event occurs. If the selector is omitted and only a function/methodname is given, registers the handler on the root element.

Parameters:

  • [selector] String optional

    Selector to match elements against

  • handler String | Function

    Eventhandler function or method name

Returns:

This:

The instance

Example:

import DOMModule from './modules/__base/dommodule';

class MyClass extends DOMModule {
    render() {
        this.onMove('.movearea', 'moveHandle');
    }
    moveHandle(event) {
        // ... your code ...
    }
}

onPress

(
  • [selector]
  • handler
)
This

Inherited from Modules._DOMModule: development/modules/__base/dommodule.js:163

Takes a CSS style selector and a function or methodname and registers the function or method as eventhandler for all child elements of the root element which match the selector when either the mousedown/touchstart/pointerdown event occurs. If the selector is omitted and only a function/methodname is given, registers the handler on the root element.

Parameters:

  • [selector] String optional

    Selector to match elements against

  • handler String | Function

    Eventhandler function or method name

Returns:

This:

The instance

Example:

import DOMModule from './modules/__base/dommodule';

class MyClass extends DOMModule {
    render() {
        this.onPress('button', 'pressHandle');
    }
    pressHandle(event) {
        // ... your code ...
    }
}

onRelease

(
  • [selector]
  • handler
)
This

Inherited from Modules._DOMModule: development/modules/__base/dommodule.js:245

Takes a CSS style selector and a function or methodname and registers the function or method as eventhandler for all child elements of the root element which match the selector when either the mouseup/touchend/pointerup event occurs. If the selector is omitted and only a function/methodname is given, registers the handler on the root element.

Parameters:

  • [selector] String optional

    Selector to match elements against

  • handler String | Function

    Eventhandler function or method name

Returns:

This:

The instance

Example:

import DOMModule from './modules/__base/dommodule';

class MyClass extends DOMModule {
    render() {
        this.onRelease('button', 'releaseHandle');
    }
    releaseHandle(event) {
        // ... your code ...
    }
}

onResize

(
  • fn
)
This

Inherited from Modules._DOMModule: development/modules/__base/dommodule.js:569

Takes function or methodname and registers the function or method as eventhandler on the window object.

Parameters:

  • fn String | Function

    Eventhandler function or method name

Returns:

This:

The instance

Example:

import DOMModule from './modules/__base/dommodule';

class MyClass extends DOMModule {
    render() {
        this.onResize('resizeHandle');
    }
    resizeHandle(event) {
        // ... your code ...
    }
}

onSubmit

(
  • [selector]
  • handler
)
This

Inherited from Modules._DOMModule: development/modules/__base/dommodule.js:529

Takes a CSS style selector and a function or methodname and registers the function or method as eventhandler for all child elements of the root element which match the selector when submit event occurs. If the selector is omitted and only a function/methodname is given, registers the handler on the root element.

Parameters:

  • [selector] String optional

    Selector to match elements against

  • handler String | Function

    Eventhandler function or method name

Returns:

This:

The instance

Example:

import DOMModule from './modules/__base/dommodule';

class MyClass extends DOMModule {
    render() {
        this.onSubmit('.my-form', 'submitHandler');
    }
    submitHandler(event) {
        // ... your code ...
    }
}

onTransitionEnd

(
  • [selector]
  • handler
)
This

Inherited from Modules._DOMModule: development/modules/__base/dommodule.js:487

Takes a CSS style selector and a function or methodname and registers the function or method as eventhandler for all child elements of the root element which match the selector when either the transitionend/webkitTransitionEnd/mozTransitionEnd/msTransitionEnd/ oTransitionEnd event occurs. If the selector is omitted and only a function/methodname is given, registers the handler on the root element.

Parameters:

  • [selector] String optional

    Selector to match elements against

  • handler String | Function

    Eventhandler function or method name

Returns:

This:

The instance

Example:

import DOMModule from './modules/__base/dommodule';

class MyClass extends DOMModule {
    render() {
        this.onTransitionEnd('.effectarea', 'transitionEndHandle');
    }
    transitionEndHandle(event) {
        // ... your code ...
    }
}

publish

(
  • channel
  • data
)
This

Inherited from Mixins.Mediator: development/js/mixins/mediator.js:16

Allows to publish information through a channel of the mediator

Parameters:

  • channel String

    The channel to publish information through

  • data

    The data to send through

Returns:

This:

The instance

Example:

import Mediator from './mixins/mediator';

const MyClass = Mediator(class {
    constructor() {}
});

let myInstance = new MyClass();
myInstance.publish('channelName', 'foo');

removeObserver

(
  • x
  • [m = 'update']
)
This

Inherited from Mixins.Observable: development/js/mixins/observable.js:99

Removes an observer object from the observable

Parameters:

  • x Object

    The object to remove

  • [m = 'update'] Function | String optional

    Function or method used as handler

Returns:

This:

The observable instance

Example:

import Observable from './mixins/observable';

const logger = {
    update(message) {
        console.log(message);
    }
}

const MyClass = Observable(class {
    constructor() {
        this.addObserver(logger);
    }
});

let myInstance = new MyClass();
myInstance.removeObserver(logger);

removeState

(
  • state
)
This

Inherited from Mixins.FSM: development/js/mixins/fsm.js:114

Removes a state from the FSM, if it is not the active one. Please note that you have to take care to preserve a valid path of events to consume, or otherwise the FSM will be trapped in a single state (which may be fine if that is your intention)

Parameters:

  • state Object

    The state to remove

Returns:

This:

The instance

Example:

import FSM from './mixins/fsm';

const MyStates = [
    {name: 'init', events: {next: 'after'}},
    {name: 'after', events: {next: 'last', prev: 'init'}},
    {name: 'last', events: {prev: 'after'}}
];

const MyClass = FSM(class {
    constructor() {
        // New states MyClass can be in are added
        this.addStates(MyStates);
        this.removeState(MyStates[2]); // remove the 'last' state
    }
});

render

() This

Defined in development/modules/anchor/js/anchor.js:82

Renders the instance and checks if a matching reference node has been found

Returns:

This:

The instance

Example:

import AnchorTrigger from './modules/anchor/js/anchor';

const myTrigger = AnchorTrigger.of('[data-widget=AnchorTrigger]');
myTrigger.render();

startUp

() Undefined

Defined in development/modules/anchor/js/anchor.js:104

Attaches all eventlisteners to the instance

Returns:

Undefined:

Nothing

Example:

import AnchorTrigger from './modules/anchor/js/anchor';

const myTrigger = AnchorTrigger.of('[data-widget=AnchorTrigger]');
myTrigger.render().startUp();

subscribe

(
  • channel
  • handler
)
String

Inherited from Mixins.Mediator: development/js/mixins/mediator.js:39

Allows to subscribe to a channel

Parameters:

  • channel String

    The channel to subscribe to

  • handler Function

    A handler function for incoming data

Returns:

String:

A subscription identifier

Example:

import Mediator from './mixins/mediator';

const Foo = Mediator(class {
    constructor() {
        this.subscribe('BarChannel', this.handleBar, this);
    }
    handleBar(data) {
        console.log('Foo received:', data);
    }
})

const Bar = Mediator(class {
    constructor() {
        this.subscribe('FooChannel', this.handleFoo, this);
    }
    handleFoo(data) {
        console.log('Bar received:', data);
    }
});

let foo = new Foo();
let bar = new Bar();

foo.publish('FooChannel', 'Info from Foo');
// logs "Bar received: Info from Foo"

bar.publish('BarChannel', 'Info from Bar');
// logs "Foo received: Info from Bar"

unsubscribe

(
  • identifier
)
Boolean

Inherited from Mixins.Mediator: development/js/mixins/mediator.js:81

Allows to subscribe to a channel

Parameters:

  • identifier String

    A subscription ID returned from subscribe()

Returns:

Boolean:

True on success, false on failure

Example:

import Mediator from './mixins/mediator';

const Foo = Mediator(class {
    constructor() {
        this.listens = this.subscribe('self', this.handler, this);
    }
    handler(data) {
        console.log('Foo received:', data);
    }
    unlisten() {
        return this.unsubscribe(this.listens);
    }
})

let foo = new Foo();
foo.publish('self', 1);
// logs "Foo received: 1"

foo.unlisten()

foo.publish('self', 1);
// nothing happens