LAST-VERSION filMcsLjs.html

cpt.language.Javascript (ljs)

ljs'Description

Javascript (ljs) is the GENERIC language of browser-javascript (ljb, client-side) and Node-javascript (ljn, server-side) and other differentiations.

Javascript was originally developed in {1995} by Brendan-Eich, at Netscape-Communications-Corporation. [en.wikipedia.org]

My goal here is my text to be MONOSEMANTIC as possible, in contrast to existing texts, by defining most of the-names of my sentences.
ALSO, my text differs than the traditional one.
I publish STRUCTURED-CONCEPTS|ModelConcepts (with attributes also concepts) in contrast to traditional text, that describes concepts.

This is a living concept (= an evolving concept), see and reference by version.
Version last.minor is dynamic (do not reference with it), all others are static.
Even though the-work I have-put on this webpage-concept is NOT a small amount, much more is needed.

ljs'Name

Name:
* cpt.language.javascript,
* cpt.javascript,
* cpt.ljs,
* javascript-cpt,
* ljs-cpt,

History:
Although it was developed under the name Mocha, the language was officially called LiveScript when it first shipped in beta releases of Netscape Navigator 2.0 in September 1995, but it was renamed JavaScript when it was deployed in the Netscape browser version 2.0B3.
The change of name from LiveScript to javascript roughly coincided with Netscape adding support for Java technology in its Netscape Navigator Web browser.
The final choice of name caused confusion, giving the impression that the language was a spin-off of the Java programming language, and the choice has been characterized as a marketing ploy by Netscape to give javascript the cachet of what was then the hot new Web programming language.

[https://en.wikipedia.org/wiki/javascript#Beginnings_at_Netscape]

"JavaScript" is a trademark of Oracle Corporation.
It is used under license for technology invented and implemented by Netscape Communications and current entities such as the Mozilla Foundation.

[https://en.wikipedia.org/wiki/JavaScript#Trademark]
===
THEN, JavaScript (with JS capital) is the-javascript of Mozilla.
I am-using the-names 'javascript' and 'ljs' for the generic language.
[HmnSynagonism.2016-07-22]

ljs'Generic-chain

Generic-chain:
* programing-language,
* computer-language,
* mapping-method,
* method,
* info,
* model,
* entity,

ljs'Archetype

Description:
All languages, human and computer, MAP (represent | translate) one entity (the-archetype) to another (model|code|algorithm), for a-communication reason.
Programing-languages map human-information and human-information-processing in a-format that machines can process.
A-programer MUST-KNOW an-archetype first, in order to create a-program.

Name:
* cpt.ljs'archetype,
* cpt.ljsarcho,

Specific:
* ljb-archetype,
* ljn-archetype,

ljs'Algorithm (Model)

Description:
An-archetype[1] in programming-languages, usually, is a-doing of processing information by humans.
In order to do this process a-machine, a-programer must translate|represent it[1] in a-format with a-programing-language's constructs.
This representation (model) is an-algorithm.
The-programer first is-thinking the-algorithm in his native-natural-language, but writes down it in a-format that machines understand, the-code.
An-algorithm is a-document with a whole-part-tree structure, the-syntax-tree.

Name:
* cpt.ljs'algorithm,
* cpt.ljs'model,
* cpt.ljsalgo,
* cpt.ljsdoc,
* cpt.ljs'doc,

ljsalgo'Format

Description:
An-algorithm can-be-written in many formats, natural-language, flowchart, code.
All formats represent information (archetypes) that machines can PROCESS but machines do-not-UNDERSTAND, at least today, all formats and this is the-reason for programing-languages existence.
Natural-language is a human-friendly format, but unfriendly for the-machines.
Flowchart, is a graphical format, like the natural-language format.
Code, is the-format that programing-language define and understand the-machines.

Name:
* cpt.ljs'algo'format,
* cpt.ljsalgo'format,
* cpt.ljsalgo-format,

Specific:
* Natural-language,
* Flowchart,
* Code,
* Web-IDL,

ljsalgo'Code

Description:
The-code[1] is a-format of an-algorithm that is-understood both by humans and machines and it[1] is-defined by the-language.

Name:
* cpt.ljs'code,
* cpt.ljscode,
* cpt.ljscode-format,
* cpt.ljssource-code,
* cpt.ljscod,
* source-code-cpt,

ljsalgo'Syntax-tree

Description:
An-algorithm is a-MODEL of an-archetype constructed as the-language defines.
THE-STRUCTURE of an-algorithm is a-WHOLE-PART-TREE of units, semantic-units, phrases, sentences, sections of the-language which parts we define in the-next sections.
This whole-part-tree is the-syntax-tree of an-algorithm.
In contrast, the-API of the-language, is structured in a-whole-part-tree and in a-generic-part-tree.

Name:
* cpt.ljs'algorithm-tree,
* cpt.ljs'syntax-tree,
* cpt.ljs'syntax-whole-part-tree,
* cpt.ljs'syntax-wptree,
* cpt.ljssyntax-tree,

ljsalgo'UNIT (unt)

Description:
In order to create an-algorithm in any format, we must use other entities, that REPRESENT NOTHING in archetype and are INDIVISIBLE.
These are the-units of the-algorithm, and the entire algorithm is a whole-part-tree system of constructs of these units.
Natural-languages use sounds or symbols.
Flowcharts use graphs.
Code uses computer-symbols, the-unicode-characters, groups of bits in binary-code.
Ljb and ljn use the same code-units.

Name:
* cpt.ljs'algo-unit,
* cpt.ljs'unit,
* cpt.ljsunit,

ljbunit'Code

Description:
Code-units are the-units of code.
Ljs-code is case-sensitive and its units are the-Unicode character-set.

Name:
* cpt.ljs'code-unit,
* cpt.ljsunit.code,
* cpt.ljscode-unit,

ljsalgo'WORD (wrd)

Description:
Words are combinations of units, that REPRESENT NOTHING, the-language uses to create whole constructs with meaning (= denote archetype).

Name:
* cpt.ljs'algo-word,
* cpt.ljs'word,
* cpt.ljsword,

ljsalgo'SEMANTIC-UNIT (sut)

Description:
An-algorithm is a-document with a-whole-part-tree-structure created by combining simpler parts.
The-units (indivisible parts) that DENOTE ARCHETYPE, used to create an-algorithm, are the-semantic-units.
Programing-languages use different semantic-units and combinations of semantic-units to create algorithms that map the same archetype.

Name:
* cpt.ljs'semantic-unit,
* cpt.ljssemantic-unit,
* cpt.ljsunit.semantic,
* cpt.ljssut,
* cpt.ljssunit,
* cpt.ljsuntSmc,

Whole-chain:
=== (syntax-wptree)
* ljs-phrase,
* ljs-sentence,
* ljs-section,
* ljs-library,
* ljs-program,
=== (API-wptree)
* another semantic-unit,
...
* most-whole-object,

Generic-chain:
* object,
or
* objectNo,

Part:
* ljs-word,
* ljs-unit,

ljsalgo'sut'Code

Description:
Code-semantic-unit is a-semantic-unit written in code-format.

Name:
* cpt.ljs'semantic-unit.code,
* cpt.ljssemantic-unit.code,
* cpt.ljscode-semantic-unit,

ljsalgo'sut.SPECIFIC

Specific:
Ljs uses only 12 semantic-units to create algorithms:
01) a - Array,
02) b - Boolean,
03) f - Function,
04) l - nuLl,
05) m - Module,
06) n - Number,
07) o - Object,
08) r - Regexp,
09) s - String,
10) u - Undefined,
11) v - name-Value-pair,
12) x - miXed,

Specific.alphabetically:
* array--semantic-unit,
* boolean--semantic-unit,
* custom--semantic-unit,
* customNo--semantic-unit,
* function--semantic-unit,
* ljb-semantic-unit,
* ljn-semantic-unit,
* name-semantic-unit,
* nameNo-semantic-unit,
* name-value-pair-mixed--semantic-unit,
* name-value-pair-mixedNo--semantic-unit,
* name-value-pair-No--semantic-unit,
* null--semantic-unit,
* number--semantic-unit,
* object--semantic-unit,
* objectNo--semantic-unit,
* regexp--semantic-unit,
* string--semantic-unit,
* undefined--semantic-unit,

ljssut.SPECIFIC-DIVISION.dialect

Specific:
* ljb-semantic-unit,
* ljn-semantic-unit,

ljssut.SPECIFIC-DIVISION.object

Specific:
* object-semantic-unit,
* objectNo-semantic-unit,

ljssut.objectNo

Description:
ObjectNo is a-semantic-unit which is NOT object, it is NOT specific of Object.prototype.
Only 2 semantic-units are not objects: null, undefined.

Name:
* cpt.ljsobjectNo-semantic-unit,
* cpt.ljs'objectNo,
* cpt.ljsobjectNo,

ljssut.SPECIFIC-DIVISION.name

Specific:
* name-semantic-unit,
* nameNo-semantic-unit,

ljssut.NameNo

Description:
NameNo is a-semantic-unit which HAS NO a-name associated with it.

Name:
* cpt.ljs'anonymous-semantic-unit,
* cpt.ljsanonymous-semantic-unit,
* cpt.ljsnameNo-semantic-unit,
* cpt.ljsname-value-pair-No-semantic-unit,
* cpt.ljs'nameNo,
* cpt.ljsnameNo,

ljssut.SPECIFIC-DIVISION.creator

Specific:
* custom-semantic-unit,
* customNo-semantic-unit,

ljssut.Custom

Description:
A-semantic-unit created by a-programer.

Name:
* cpt.ljs'builtinNo-semantic-unit,
* cpt.ljsbuiltinNo-semantic-unit,
* cpt.ljs'custom-semantic-unit,
* cpt.ljscustom-semantic-unit,
* cpt.ljs'nativeNo-semantic-unit,
* cpt.ljsnativeNo-semantic-unit,
* cpt.ljs'standardNo-semantic-unit,
* cpt.ljsstandardNo-semantic-unit,

ljssut.CustomNo

Description:
A-semantic-unit created by the-language-creator.

Name:
* cpt.ljs'builtin-semantic-unit,
* cpt.ljs'built-in-semantic-unit,
* cpt.ljs'customNo-semantic-unit,
* cpt.ljs'native-semantic-unit,
* cpt.ljs'standard-semantic-unit,
* cpt.ljsbuiltin-semantic-unit,
* cpt.ljsbuilt-in-semantic-unit,
* cpt.ljscustomNo-semantic-unit,
* cpt.ljsnative-semantic-unit,
* cpt.ljsstandard-semantic-unit,

ljsalgo'sut.ARRAY (ljsa)

Description:
Array is an-ordered-collection of other semantic-units.
Code-example:
var a = [true, 1, {n:1}, /d/, 's'];

Name:
* cpt.ljs'array,
* cpt.ljsarray,
* cpt.ljsa,

Generic-chain:
* Array.prototype, ([].__proto__ === Array.prototype //true)
* Object.prototype, ([].__proto__.__proto__ === Object.prototype //true)

ljsa'Creating

Description:
Code:
var a1 = [1, 's'];
//===
var a2 = new Array(1, 's');

Name:
* cpt.ljsa'creation,
* cpt.ljs'array'creation,
* cpt.ljsarray'creation,

ljsa'Element

Description:
Elements|items are the-entities an-array contains.
To access them ljs uses the-code:
a[nIndex]

Name:
* cpt.ljs'array'element,
* cpt.ljsarray'element,
* cpt.ljsa'element,
* cpt.ljsarray'item,
* cpt.ljsa'item,

ljsa'Index

Description:
Index-of-array is a-number (starts with 0) that denotes the-order of one of its elements.

Name:
* cpt.ljs'array'index,
* cpt.ljsarray'index,
* cpt.ljsa'index,

ljsa'Member

Description:
Arrays are-considered objects of the-Array-constructor-function, with generic the-Array.prototype-object.
In other words, the-members of the-Array.prototype are-inherited by all arrays.
Also, any array[1] can-have extra members in addition to its[1] inherited members and to its[1] elements.
Code:
a.n = 3;

Name:
* cpt.ljs'array'member,
* cpt.ljsarray'member,
* cpt.ljsa'member,

ljsa'Array-function

Description:
Array is a-built-in-function and is-considered the-constructor, of all arrays.
Then, Array.prototype is the-parent-generic-object of all arrays.

Name:
* cpt.ljsf.Array,
* cpt.ljsArray,
* cpt.ljs'Array-constructor,
* cpt.ljsArray-constructor,
* cpt.ljsArray-constructor-function,
* cpt.ljs'Array-function,
* cpt.ljsArray-function,

Generic-chain:
* Function.prototype (Array.__proto__ === Function.prototype //true),
* Object.prototype (Array.__proto__.__proto__ === Object.prototype //true),

ljsa'Array.prototype

Description:
Array.prototype is the-generic-object, of all arrays.
In other words, its members are-inherited by all arrays.

Name:
* cpt.ljso.Array.prototype,
* cpt.ljs'Array.prototype,
* cpt.ljsArray.prototype,
* cpt.ljsArray.prototype-object,

Generic-chain:
* Object.prototype (Array.prototype.__proto__ === Object.prototype //true),

Member:
Code
(ljn.622):
> Object.getOwnPropertyNames(Array.prototype).sort()
[ 'concat', 'constructor', 'copyWithin', 'entries', 'every', 'fill', 'filter', 'find', 'findIndex', 'forEach', 'includes', 'indexOf', 'join', 'keys', 'lastIndexOf', 'length', 'map', 'pop', 'push', 'reduce', 'reduceRight', 'reverse', 'shift', 'slice', 'some', 'sort', 'splice', 'toLocaleString', 'toString', 'unshift' ]

(Chrome.50):
> Object.getOwnPropertyNames(Array.prototype).sort()
["concat", "constructor", "copyWithin", "entries", "every", "fill", "filter", "find", "findIndex", "forEach", "includes", "indexOf", "join", "keys", "lastIndexOf", "length", "map", "pop", "push", "reduce", "reduceRight", "reverse", "shift", "slice", "some", "sort", "splice", "toLocaleString", "toString", "unshift"]

(Firefox.45):
> Object.getOwnPropertyNames(Array.prototype).sort()
["concat", "constructor", "copyWithin", "entries", "every", "fill", "filter", "find", "findIndex", "forEach", "includes", "indexOf", "join", "keys", "lastIndexOf", "length", "map", "pop", "push", "reduce", "reduceRight", "reverse", "shift", "slice", "some", "sort", "splice", "toLocaleString", "toSource", "toString", "unshift"]

(Edge.20):
> Object.getOwnPropertyNames(Array.prototype).sort()
["concat", "constructor", "copyWithin", "entries", "every", "fill", "filter", "find", "findIndex", "forEach", "indexOf", "join", "keys", "lastIndexOf", "length", "map", "pop", "push", "reduce", "reduceRight", "reverse", "shift", "slice", "some", "sort", "splice", "toLocaleString", "toString", "unshift", "values"]

(Safari.5.1.7):
> Object.getOwnPropertyNames(Array.prototype).sort()
["concat", "constructor", "every", "filter", "forEach", "indexOf", "join", "lastIndexOf", "length", "map", "pop", "push", "reduce", "reduceRight", "reverse", "shift", "slice", "some", "sort", "splice", "toLocaleString", "toString", "unshift"]

ljsalgo'sut.BOOLEAN (ljsb)

Description:
Boolean is any of the two semantic-units: false, true.

Name:
* cpt.ljs'boolean,
* cpt.ljsboolean,
* cpt.ljsb,
* ljsboolean-cpt,
* ljsb-cpt,

Generic-chain:
* Boolean.prototype, (true.__proto__ === Boolean.prototype //true)
* Object.prototype, (true.__proto__.__proto__ === Object.prototype //true)

Specific:
* false,
* true,

ljs'Boolean.prototype

Description:
Boolean.prototype is the-generic-object, of booleans.
In other words, its members are-inherited by booleans.

Name:
* cpt.ljso.Boolean.prototype,
* cpt.ljs'Boolean.prototype,
* cpt.ljsBoolean.prototype,
* cpt.ljsBoolean.prototype-object,

Generic-chain:
* Object.prototype (Boolean.prototype.__proto__ === Object.prototype //true),

Member:
(ljn.630):
> Object.getOwnPropertyNames(Boolean.prototype).sort()
[ 'constructor', 'toString', 'valueOf' ]

(Chrome.50):
> Object.getOwnPropertyNames(Boolean.prototype).sort()
["constructor", "toString", "valueOf"]

(Firefox.46):
> Object.getOwnPropertyNames(Boolean.prototype).sort()
["constructor", "toSource", "toString", "valueOf"]

(Edge.20):
> Object.getOwnPropertyNames(Boolean.prototype).sort()
["constructor", "toString", "valueOf"]

(Safari.5.1.7):
> Object.getOwnPropertyNames(Boolean.prototype).sort()
["constructor", "toString", "valueOf"]

ljsalgo'sut.FUNCTION (ljsf)

Description:
Function is the-semantic-unit that PROCESSES information.
Optionally has input and output.

Name:
* cpt.ljs'function,
* cpt.ljsfunction,
* cpt.ljsf,
* ljsfunction-cpt,
* ljsf-cpt,

Whole-chain:
* the-semantic-unit in which defined,
...
* most-whole-object,

Generic-chain:
* Function.prototype, (var f = function(){}; f.__proto__ === Function.prototype //true)
* Object.prototype, (f.__proto__.__proto__ === Object.prototype //true)

ljsf'Creation

Description:
With a-compound-sentence, we define|create a-function.
We define its input, output and what info-processing will-do.
Code:
function fName() { // inside parentheses we write the input identifiers
  //what to do
  //last, what to return
}

or
var fName = function() {
  //what to do
  //last, what to return
}

In the second case, we define one name-value-pair with name fName and value an anonymous function.

Name:
* cpt.ljs'function-creation,
* cpt.ljsfunction-creation,
* cpt.ljs'function-definition,
* cpt.ljsfunction-definition,
* cpt.ljsf'creation,
* cpt.ljsf'definition,

ljsf'Call

Description:
Function-call is the-process of setting a-function to work.
We define a-function once, we call it as many times as we wish.
We use the next phrase, to call a-function.
Code:
fName()
Inside the-parentheses we put the-values of the-identifiers used in the-definition.

Name:
* cpt.ljs'function-call,
* cpt.ljsfunction-call,
* cpt.ljs'function-execution,
* cpt.ljsfunction-execution,
* cpt.ljs'function-invocation,
* cpt.ljsfunction-invocation,
* cpt.ljsf'call,
* cpt.ljsf'execution,
* cpt.ljsf'invocation,

ljsf'Input

Description:
Function's-input is optional information (semantic-units) we give to a-function to do its work.

Name:
* cpt.ljs'function-input,
* cpt.ljsfunction-input,
* cpt.ljsfunction's-input,
* cpt.ljsf'input,

Function's-parameter:
In a-function's-definition, as input information we do-not-give values, we give identifiers of name-value-pairs.
These input identifiers are-called PARAMETERS.
I use the-notation: xNameIn where 'x' denotes what semantic-unit is.

Function's-argument:
When we call a-function, as input information we give values, not identifiers.
These input values are-called ARGUMENTS.

ljsf'Output

Description:
Function's-output is optional information (semantic-unit) we could-RECEIVE from a-function.
If a-function has no output, then the-output is-considered the-undefined-semantic-unit.

Name:
* cpt.ljs'function-output,
* cpt.ljsfunction-output,
* cpt.ljsfunction's-output,
* cpt.ljsf'output,

Return-sentence:
The last sentence in the-definition-of-a-function is the-return-sentence, the-sentence that denotes what the-function will return.
Code: return o;

Name:
* cpt.ljs'return-sentence,
* cpt.ljsreturn-sentence,
* cpt.ljs'return-statement,
* cpt.ljsreturn-statement,
* cpt.ljs'sentence.return,
* cpt.ljssentence.return,

ljsf'Name

Description:
The-name of a-function it's a little tricky business.
In this definition: function f(){}, the-name is 'f': f.name //"f"
In this definition: var f = function(){}, there is no name: f.name //""
In this definition: var f1 = function f2(){}, the-name is 'f2': f1.name //"f2"; f2.name //error
In all other name-value-pairs we consider the-identifier as 'name'.
So when we need to create recursive-functions (= functions which call themselves), we use the first definition where the-name and the-reference to the-function are the-same.

ljsf'A-function-is-an-object

Description:
This natural-language sentence is ambiguous.
First of all, the-verb 'is' has many meanings, eg 'has', 'is-specific-of', 'is-part-of' etc.
In javascript means that a-function is specific of the-object Object.prototype, then and a-function is an-object.
Thus, a-function can-have members, like an-object.
A-function has the-members of its generics-chain.
BUT a-function has and other characteristics that an-object can-not have.
We can-call a-function, but not an-object.
Then, the correct sentence is: A-function is a specific of Object.prototype.

ljsf'Function.prototype

Description:
Function.prototype[1] is the-generic-object, of all functions.
In other words, its[1] members are-inherited by all functions.
Usually, Constructor.prototype is an-object.
But Function.prototype is a-function: typeof Function.prototype //"function"

Name:
* cpt.ljs'Function.prototype,
* cpt.ljsFunction.prototype,
* cpt.ljsFunction.prototype-function,
* cpt.ljsf.Function.prototype,

Whole-chain:
* Function,
* most-whole-object,

Generic-chain:
* Object.prototype (Function.prototype.__proto__ === Object.prototype //true),

Member:
Code (Chrome.50):
> Object.getOwnPropertyNames(Function.prototype).sort()
["apply", "arguments", "bind", "call", "caller", "constructor", "length", "name", "toString"]

(Firefox.46):
> Object.getOwnPropertyNames(Function.prototype).sort()
["apply", "arguments", "bind", "call", "caller", "constructor", "isGenerator", "length", "name", "toSource", "toString"]

(Edge.20):
> Object.getOwnPropertyNames(Function.prototype).sort()
["apply", "arguments", "bind", "call", "caller", "constructor", "length", "name", "toString"]

(Safari.5.1.7):
> Object.getOwnPropertyNames(Function.prototype).sort()
["apply", "bind", "call", "constructor", "length", "name", "toString"]

Specific:
* Function,
* Object,
* ...
* all builtin functions,
* all custom-functions,

ljsf'Function-function

Description:
Function is the-constructor, of all functions:
> var f = function(){};
undefined
> f.constructor
function Function() { [native code] }

Name:
* cpt.ljsFunction,
* cpt.ljs'Function-constructor,
* cpt.ljsFunction-constructor,
* cpt.ljs'Function-function,
* cpt.ljsFunction-function,

Whole-chain:
* most-whole-object,

Generic-chain:
* Function.prototype, (Function.__proto__ === Function.prototype //true),
It is important to mention here that Function CONTAINS its generic-object, the-Function.prototype.
* Object.prototype, (Function.__proto__.__proto__ === Object.prototype //true)

Member:
Code (Chrome.50):
> Object.getOwnPropertyNames(Function).sort()
[]

(Firefox.46):
> Object.getOwnPropertyNames(Function).sort()
[]

(Edge.20):
> Object.getOwnPropertyNames(Function).sort()
[]

(Safari.5.1.7):
> Object.getOwnPropertyNames(Function).sort()
[]

ljsf.SPECIFIC

Specific.alphabetically:
* constructor-function,
* custom-function,
* customNo-function,
* method-function,
* methodNo-function,
* named-function,
* namedNo-function,
* object-returning-function,
* operator-function,
* self-executing-function,

ljsf.CONSTRUCTOR

Description:
Constructor is any function used to create objects.
Code:
var o = new fName();

Name:
* cpt.ljs'constructor,
* cpt.ljsconstructor,
* cpt.ljsconstructor-function,
* cpt.ljsf.constructor,
* cpt.ljsfunction.constructor,
===
Usually the-names of individual constructors begin with capital-letters.

Constructor.prototype:
The-members of this special member of a-constructor, are-inherited by the-objects-created-by-a-constructor.
In other words, Constructor.prototype is the-generic-object of a-constructor's objects.

ljsf.METHOD

Description:
Method is a-function member of an-object.

Name:
* cpt.ljs'method,
* cpt.ljsmethod,
* cpt.ljs'function.method,
* cpt.ljsfunction.method,
* cpt.ljsf.method,

ljsf.NAMED

Description:
Named-function is a-function which has name.

// defined as:
function f(){};
// or
var f1 = function f2(){};

Name:
* cpt.ljs'named-function,
* cpt.ljs'function.named,
* cpt.ljsfunction.named,
* cpt.ljsf.named,

ljsf.NAMED.NO

Description:
NamedNo-function is a-function which has NO name.

// defined as:
var f = function(){};

Name:
* cpt.ljs'anonymous-function,
* cpt.ljs'namedNo-function,
* cpt.ljs'function.namedNo,
* cpt.ljsfunction.namedNo,
* cpt.ljsf.namedNo,

ljsf.OBJECT-RETURNING

Description:
Objects have no scope.
To overcome this, we create objects by creating functions[2], which have scope, that[1] return the-object we want.
Code:
function f() {
  var n = 1;
  function f1(){var n2 = n;}
  return {
    f1: f1;
    n: n;
  };
}

Name:
* cpt.ljs'object-factory-function,
* cpt.ljsobject-factory-function,
* cpt.ljs'object-returning-function,
* cpt.ljsobject-returning-function,
* cpt.ljs'function.object-returning,
* cpt.ljsfunction.object-returning,
* cpt.ljsf.object-factory,
* cpt.ljsf.object-returning,

ljsf.OPERATOR

Description:
Operators are special functions with code similar to natural-languages and names special-symbols and special syntax.
Operators[1] are built-in, and a-programer calls them[1].

Name:
* cpt.ljs'operator,
* cpt.ljsoperator,
* cpt.ljsopr,

Operand:
Description:
Operands are the INPUT information of operators.

Name:
* cpt.lsjoperand,

ljsopr.SPECIFIC

Specific.alphabetically:
* arithmetic-operator,
* assignment-operator,
* binary-operator,
* bitwise-operator,
* comma-operator,
* comparison-operator,
* conditional-operator,
* logical-operator,
* relational-operator,
* string-operator,
* ternary-operator,
* unary-operator,

ljsf.SELF-EXECUTING

Description:
Self-executing-function is a-function which defined and called at the same time.
Code:
(function() {
  //what to do
  //last, what to return
})();

Name:
* cpt.ljs'function.self-executing,
* cpt.ljsfunction.self-executing,
* cpt.ljsf.self-executing,
* cpt.ljs'self-executing-function,
* cpt.ljsself-executing-function,

Immediately-invoked-function-expression (IIFE):
It is the-sentence in the-code that defines and calls the-function.

ljsalgo'sut.NULL (ljsl)

Description:
Null is a special semantic-unit that denotes no-information, similar to zero quantity.

Name:
* cpt.ljs'null,
* cpt.ljsnull,
* cpt.ljsl,
* ljsnull-cpt,
* ljsl-cpt,

Generic-chain:
* objectNo,
* semantic-unit,
===
'null is not an object'.
In other words, null is NOT SPECIFIC of an-ljs-object, it does not inherit the-members of an-object.

Code:
null

ljsalgo'sut.NUMBER (ljsn)

Description:
Number is a-semantic-unit that denotes numbers in archetype.

Name:
* cpt.ljs'number,
* cpt.ljsnumber,
* cpt.ljsn,
* ljsn-cpt,

Generic-chain:
* Number.prototype, ((3).__proto__ === Number.prototype //true)
* Object.prototype, ((3).__proto__.__proto__ === Object.prototype //true)

ljsn'Number.prototype

Description:
Number.prototype is the-generic-object, of all numbers.
In other words, its members are-inherited by all numbers.

Name:
* cpt.ljso.Number.prototype,
* cpt.ljs'Number.prototype,
* cpt.ljsNumber.prototype,
* cpt.ljsNumber.prototype-object,

Generic-chain:
* Object.prototype (Number.prototype.__proto__ === Object.prototype //true),

Member:
(Node.6.3.0):
> Object.getOwnPropertyNames(Number.prototype).sort()
[ 'constructor', 'toExponential', 'toFixed', 'toLocaleString', 'toPrecision', 'toString', 'valueOf' ]

(Chrome.50):
> Object.getOwnPropertyNames(Number.prototype).sort()
["constructor", "toExponential", "toFixed", "toLocaleString", "toPrecision", "toString", "valueOf"]

(Firefox.46):
> Object.getOwnPropertyNames(Number.prototype).sort()
["constructor", "toExponential", "toFixed", "toLocaleString", "toPrecision", "toSource", "toString", "valueOf"]

(Edge.20):
> Object.getOwnPropertyNames(Number.prototype).sort()
[constructor", "toExponential", "toFixed", "toLocaleString", "toPrecision", "toString", "valueOf"]

(Safari.5.1.7):
> Object.getOwnPropertyNames(Number.prototype).sort()
["constructor", "toExponential", "toFixed", "toLocaleString", "toPrecision", "toString", "valueOf"]

ljsalgo'sut.OBJECT (ljso)

Description:
Object is a-collection of name-value-pairs, which inherits the-members of the-Object.prototype, in other words it is SPECIFIC of the-Object.prototype.
Objects are semantic-units that map concepts.
The famous sentence 'everything is an object', is wrong because there are and no-objects.
The correct sentence is: 'almost everything is an-Object.prototype'.

Name:
* cpt.ljs'object,
* cpt.ljsobject,
* cpt.ljso,
* ljsobject-cpt,
* ljso-cpt,

Whole-chain:
=== (syntax-wptree)
* ljs-phrase,
* ljs-sentence,
* ljs-library,
* ljs-program,
=== (API-wptree)
* another semantic-unit,
...
* window,

Generic-chain:
A-generic-object inherits its members to its specifics.
===
* Object.prototype, (literal-objects ({}).__proto__ === Object.prototype //true)
or
* Constructor.prototype, (constructor-objects)
or
* objectX, (var o = Object.create(objectX))

ljso'Member

Description:
Members are-called the-name-value-pairs of an-object.

Name:
* cpt.ljs'object's-member,
* cpt.ljs'object'member,
* cpt.ljsobject's-member,
* cpt.ljsombr,
* Some call the-members 'properties', and some with 'properties' the non-methods members.

Creating:
a) with the-creation of the-object.
b) after object creation with the-code:
object.member = value;

Access:
To access a-member of an-object, ljs uses the-code:
object.member or
object[member]

Specific:
* Inherited: a-member of its generic-objects.
* InheritedNo,
* Method: a-member which is a-function.
* MethodNo: any other member. Some call them 'properties'.

ljso'Scope (link)

ljso.SPECIFIC

Specific.alphabetically:
* constructor-object,
* constructorNo-object,
* custom-object,
* customNo-object,
* first-class-object,
* first-class-no-object,
* literal-object,
* literalNo-object,
* most-generic-object,
* most-whole-object,

ljso.CONSTRUCTOR

Description:
Constructor-object is an-object created with a-constructor-function: var o = new Constructor();

Name:
* cpt.ljs'constructor-object,
* cpt.ljsconstructor-object,
* cpt.ljs'object.constructor,
* cpt.ljsobject.constructor,
* cpt.ljs'object-created-by-a-constructor,
* cpt.ljsobject-created-by-a-constructor,
* cpt.ljso.constructor,
===
I use to name individual constructor-objecs as: oConstructor which helps reading the-code.

Generic-chain:
* Constructor.prototype,
...
* Object.prototype,

Member:
A-constructor-object has as members the-nvps of its constructor that are-prefixed with this.
Also it inherits the-members of the-Constructor.prototype-object.

ljso.CONSTRUCTOR.NO

Description:
ConstructorNo-object is an-object NOT-CREATED with a-constructor-function: var o = new Constructor();
There are 3 cases:
a) a-literal-object.
b) var o = Object.create(o2);
Here, o2 is a-generic of o.
c) object created as a return of a-function.

Name:
* cpt.ljs'constructorNo-object,
* cpt.ljsconstructorNo-object,
* cpt.ljs'nonconstructor-object,
* cpt.ljsnonconstructor-object,
* cpt.ljs'object.constructorNo,
* cpt.ljsobject.constructorNo,
* cpt.ljs'object-not-created-by-a-constructor,
* cpt.ljsobject-not-created-by-a-constructor,
* cpt.ljso.constructorNo,

ljso.FIRST-CLASS

Description:
First-class-object is an-object which can-have members.
[https://developer.mozilla.org/en-US/docs/Web/javascript/Reference/Functions]

Name:
* cpt.ljs'first-class-object,
* cpt.ljsfirst-class-object,
* cpt.ljs'firstclass-object,
* cpt.ljsfirstclass-object,
* cpt.ljs'object.first-class,
* cpt.ljsobject.first-class,
* cpt.ljso.first-class,

Specific:
* array,
* function,
* regexp,
* number-non-literal, (var n = new Number(2))
* string-non-literal, (var s = new String('string'))

ljso.FIRST-CLASS.NO

Description:
First-class-no- object is an-object which can-NOT-have members.
[https://developer.mozilla.org/en-US/docs/Web/javascript/Reference/Functions]

Name:
* cpt.ljs'first-class-object.no,
* cpt.ljsfirst-class-object.no,
* cpt.ljs'firstclass-object.no,
* cpt.ljsfirstclass-object.no,
* cpt.ljs'object.first-class.no,
* cpt.ljsobject.first-class.no,
* cpt.ljso.first-class.no,

Specific:
* boolean,
* number-literal, (var n = 2)
* string-literal, (var s = 'string')

ljso.LITERAL

Description:
Literal-object is an-object created directly by the-programer.
Code:
var o = {
  a: [1, 's'],
  b: true,
  f: function(){},
  n: 2,
  o2: {n:1, s:'s'},
  r: /d/,
  s: 'string',
}

Name:
* cpt.ljs'literal-object,
* cpt.ljsliteral-object,
* cpt.ljs'object.literal,
* cpt.ljsobject.literal,

Generic-chain:
* Object.prototype,

ljso.LITERAL.NO

Description:
LiteralNo-object is an-object NOT created directly by the-programer.

Name:
* cpt.ljs'non-literal-object,
* cpt.ljsnon-literal-object,
* cpt.ljs'literalNo-object,
* cpt.ljsliteralNo-object,
* cpt.ljs'object.literalNo,
* cpt.ljsobject.literalNo,

Specific:
* constructor-object,
* var o = Object.create(o2);
* object created as a return of a-function.

ljsalgo'sut.REGEXP (ljsr)

Description:
RegExp (regular-expression) denotes parts of texts.
They are the-query-language for texts in archetype.
Code-example:
var r = /d/;

Name:
* cpt.ljs'regexp,
* cpt.ljsregexp,
* cpt.ljsr,
* ljsregexp-cpt,
* ljsr-cpt,

Generic-chain:
* RegExp.prototype, (/r/.__proto__ === RegExp.prototype //true)
* Object.prototype, (/r/.__proto__.__proto__ === Object.prototype //true)

ljsn'RegExp.prototype

Description:
RegExp.prototype is the-generic-object, of all regexp.
In other words, its members are-inherited by all regexp.

Name:
* cpt.ljso.RegExp.prototype,
* cpt.ljs'RegExp.prototype,
* cpt.ljs'RegExp.prototype,
* cpt.ljsRegExp.prototype,
* cpt.ljsRegExp.prototype-object,

Generic-chain:
* Object.prototype (RegExp.prototype.__proto__ === Object.prototype //true),

Member:
(Chrome.50):
> Object.getOwnPropertyNames(RegExp.prototype).sort()
["compile", "constructor", "exec", "flags", "global", "ignoreCase", "multiline", "source", "sticky", "test", "toString", "unicode"]

(Firefox.46):
> Object.getOwnPropertyNames(RegExp.prototype).sort()
["compile", "constructor", "exec", "flags", "global", "ignoreCase", "lastIndex", "multiline", "source", "sticky", "test", "toSource", "toString", "unicode"]

(Edge.20):
> Object.getOwnPropertyNames(RegExp.prototype).sort()
["compile", "constructor", "exec", "global", "ignoreCase", "lastIndex", "multiline", "options", "source", "test", "toString", "unicode"]

(Safari.5.1.7):
> Object.getOwnPropertyNames(RegExp.prototype).sort()
["compile", "constructor", "exec", "global", "ignoreCase", "lastIndex", "multiline", "source", "test", "toString"]

ljsalgo'sut.STRING (ljss)

Description:
Strings represent any text in archetype.
Strings have meaning for humans, but NOT for the-machines.
Code-example:
var s = 'string';

Name:
* cpt.ljs'string,
* cpt.ljsstring,
* cpt.ljss,
* ljsstring-cpt,
* ljss-cpt,

Generic-chain:
* String.prototype, (''.__proto__ === String.prototype //true)
* Object.prototype, (''.__proto__.__proto__ === Object.prototype //true)

ljss'String.prototype

Description:
String.prototype is the-generic-object, of all strings.
In other words, its members are-inherited by all strings.

Name:
* cpt.ljso.String.prototype,
* cpt.ljs'String.prototype,
* cpt.ljsString.prototype,
* cpt.ljsString.prototype-object,

Generic-chain:
* Object.prototype (String.prototype.__proto__ === Object.prototype //true),

Member:
(Node.6.3.0):
> Object.getOwnPropertyNames(String.prototype).sort()
[ 'anchor', 'big', 'blink', 'bold', 'charAt', 'charCodeAt', 'codePointAt', 'concat', 'constructor', 'endsWith', 'fixed', 'fontcolor', 'fontsize', 'includes', 'indexOf', 'italics', 'lastIndexOf', 'length', 'link', 'localeCompare', 'match', 'normalize', 'repeat', 'replace', 'search', 'slice', 'small', 'split', 'startsWith', 'strike', 'sub', 'substr', 'substring', 'sup', 'toLocaleLowerCase', 'toLocaleUpperCase', 'toLowerCase', 'toString', 'toUpperCase', 'trim', 'trimLeft', 'trimRight', 'valueOf' ]

(Chrome.50):
> Object.getOwnPropertyNames(String.prototype).sort()
["anchor", "big", "blink", "bold", "charAt", "charCodeAt", "codePointAt", "concat", "constructor", "endsWith", "fixed", "fontcolor", "fontsize", "includes", "indexOf", "italics", "lastIndexOf", "length", "link", "localeCompare", "match", "normalize", "repeat", "replace", "search", "slice", "small", "split", "startsWith", "strike", "sub", "substr", "substring", "sup", "toLocaleLowerCase", "toLocaleUpperCase", "toLowerCase", "toString", "toUpperCase", "trim", "trimLeft", "trimRight", "valueOf"]

(Firefox.46):
> Object.getOwnPropertyNames(String.prototype).sort()
["anchor", "big", "blink", "bold", "charAt", "charCodeAt", "codePointAt", "concat", "constructor", "contains", "endsWith", "fixed", "fontcolor", "fontsize", "includes", "indexOf", "italics", "lastIndexOf", "length", "link", "localeCompare", "match", "normalize", "repeat", "replace", "search", "slice", "small", "split", "startsWith", "strike", "sub", "substr", "substring", "sup", "toLocaleLowerCase", "toLocaleUpperCase", "toLowerCase", "toSource", "toString", "toUpperCase", "trim", "trimLeft", "trimRight", "valueOf"]

(Edge.20):
> Object.getOwnPropertyNames(String.prototype).sort()
["anchor", "big", "blink", "bold", "charAt", "charCodeAt", "codePointAt", "concat", "constructor", "endsWith", "fixed", "fontcolor", "fontsize", "includes", "indexOf", "italics", "lastIndexOf", "length", "link", "localeCompare", "match", "normalize", "repeat", "replace", "search", "slice", "small", "split", "startsWith", "strike", "sub", "substr", "substring", "sup", "toLocaleLowerCase", "toLocaleUpperCase", "toLowerCase", "toString", "toUpperCase", "trim", "trimLeft", "trimRight", "valueOf"]

(Safari.5.1.7):
> Object.getOwnPropertyNames(String.prototype).sort()
["anchor", "big", "blink", "bold", "charAt", "charCodeAt", "concat", "constructor", "fixed", "fontcolor", "fontsize", "indexOf", "italics", "lastIndexOf", "length", "link", "localeCompare", "match", "replace", "search", "slice", "small", "split", "strike", "sub", "substr", "substring", "sup", "toLocaleLowerCase", "toLocaleUpperCase", "toLowerCase", "toString", "toUpperCase", "trim", "trimLeft", "trimRight", "valueOf"]

ljsalgo'sut.UNDEFINED (ljsu)

Description:
Undefined is a-semantic-unit that denotes a-name-value-pair without value assigned (initialized).
Also it is-used to denote that a-function has no output.
Code: undefined

Name:
* cpt.ljs'undefined,
* cpt.ljsundefined,
* cpt.ljsu,
* ljsundefined-cpt,
* ljsu-cpt,

Generic-chain:
* objectNo,
* semantic-unit,

ljsalgo'sut.NAME-VALUE-PAIR (ljsv)

Description:
In order to create combinations of semantic-units we need to give names to semantic-units and combinations of semantic-units.
This pair of a-name and the-information associated with this name is the-name-value-pair (variable).

Name:
* cpt.ljs'name-value-pair,
* cpt.ljsname-value-pair,
* cpt.ljs'variable,
* cpt.ljsvariable,
* ljsname-value-pair,
* cpt.ljs'nvp,
* cpt.ljsnvp,
* cpt.ljsv,

Generic-chain:
* the-generic of its value.

ljsv'identifier

Description:
The-name of a-name-value-pair is-called idenfier.
An-identifier must start with a letter, underscore (_), or dollar sign ($); subsequent characters can also be digits (0-9).

Name:
* cpt.ljs'identifier,
* cpt.ljsidentifier,

ljsv'identifier

Description:
Typename|valuename is an-identifier which denotes its type|value.
Since {2014.08.05} I am-using typenames in my code, which makes the-code much more readable.

Name:
* cpt.ljs'typename,
* cpt.ljs'valuename,
* ljs'typename-cpt,
* ljs'valuename-cpt,
* typename-cpt,
* valuename-cpt,

Specific:
In javascript we need only 11 typenames to denote ALL its types:
01) aName for Arrays,
02) bName for Booleans,
03) fName for Functions,
04) lName for nuLl,
05) mName for Modules,
06) nName for Numbers,
07) oName for Objects,
08) rName for Regexps,
09) sName for Strings,
10) uName for Undefined,
11) xName for miXed-name-value-pairs,

ljsv'value

Description:
The-information we assign in the-name of a-name-value-pair is-called value.

Name:
* cpt.ljs'value,
* cpt.ljsvalue,

ljsv'definition (link)

ljsv.SPECIFIC

Specific:
* const-nvp,
* let-nvp,
* var-nvp,
===
* mixed-nvp,
* mixedNo-nvp,

ljsv.SPECIFIC-DIVISION.value

Specific:
* mixed-name-value-pair--semantic-unit,
* mixedNo-name-value-pair--semantic-unit,

MixedNo-name-value-pair--semantic-unit:
Description:
MixedNo-name-value-pair is a-name-value-pair which ASSOCIATES only ONE type of value with a-name.

Name:
* cpt.ljs'mixedNo-semantic-unit,
* cpt.ljsmixedNo-semantic-unit,
* cpt.ljs'mixedNo-name-value-pair--semantic-unit,
* cpt.ljsmixedNo-name-value-pair--semantic-unit,
* cpt.ljs'mixedNo,
* cpt.ljsmixedNo,

ljsv.const

Description:
The const declaration creates a read-only reference to a value.
It does not mean the value it holds is immutable, just that the variable identifier cannot be reassigned.
[https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/const]

Name:
* cpt.ljs'const-name-value-pair,
* cpt.ljsconst-name-value-pair,
* cpt.ljs'constant,
* cpt.ljs'const,
* cpt.ljsconst,

ljsv.let

Description:
The let statement declares a block scope local variable, optionally initializing it to a value. [https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/let]

Name:
* cpt.ljs'let-name-value-pair,
* cpt.ljslet-name-value-pair,
* cpt.ljs'let,
* cpt.ljslet,

ljsv.var

Description:
The scope of a variable declared with var is its current execution context, which is either the enclosing function or, for variables declared outside any function, global. [https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/var]

Name:
* cpt.ljs'var-name-value-pair,
* cpt.ljsvar-name-value-pair,
* cpt.ljs'var,
* cpt.ljsvar,

ljsalgo'sut.MIXED (ljsx)

Description:
Mixed is a-name-value-pair that contains different semantic-units.

Name:
* cpt.ljs'mixed,
* cpt.ljs'mixed-semantic-unit,
* cpt.ljsmixed,
* cpt.ljsx,
* ljsmixed-cpt,
* ljsx-cpt,

ljsalgo'sut.API

Description:
API is a-set of semantic-units.
An-API, like any conceptual-information, is-structured at the SAME time, into 2 different tree-structures:
1) A-whole-part-tree with root-node the-most-whole-object and
2) A-generic-specific-tree with root-node the-most-generic-object (Object.prototype).
The-discovery (not invention) that an-API has 2 different tree-structures, is mine which I first discovered to have any human-conceptual-information.

Name:
* cpt.ljs'API,
* cpt.ljs'Application-Programming-Interface,
* cpt.ljs'Application-Programing-Interface,
* cpt.ljsapi,
* API-cpt,

ljsapi'Most-whole-object (global)

Description:
The whole-part relations of semantic-units form a whole-part-tree structure.
The-ROOT-node of this structure is the most-whole-object and contains all others.
It is called the-global-object.
With the same name are-called and its children (not its descendants).
In ljb, this is the-window-object.
In ljn, this is the-global-object.

Name:
* cpt.ljs'most-whole-object,
* cpt.ljs'global-object,
* cpt.ljsmost-whole-object,
* cpt.ljsmwo,
* most-whole-object-cpt,

Whole-chain:
* none,

Generic-chain:
...
* Object.prototype,
LOOK-THAT: the-most-whole-object is specific of the-most-generic-object.

ljsmwo'Member

Description:
The-members of the-most-whole-object are-called ALSO 'globals'.
To avoid ambiguity I will-call them 'global-members'.

Name:
* cpt.ljs'global-member,
* cpt.ljs'global,
* cpt.ljs'globals,
* cpt.ljs'member-of-most-whole-object,
* cpt.ljsglobal,

Specific:
* ljb-global-member,
* ljn-global-member,

ljsapi'Most-generic-object (Object.prototype)

Description:
All ljs-objects inherit the-members of this object.
Object.prototype is the-ROOT node of the-API-generic-specific-tree of ALL javascript dialects.

Name:
* cpt.ljs'Object.prototype,
* cpt.ljsObject.prototype,
* ljsObject.prototype-cpt,
* Object.prototype-cpt,

Whole-chain:
* Object,
* most-whole-object,
LOOK-THAT: the-most-generic-object is part of the-Object-function, which is part of the-most-whole-object.

Generic-chain:
* none,

Member:
(ljn.6-3-1)
> Object.getOwnPropertyNames(Object.prototype).sort()
[ '__defineGetter__', '__defineSetter__', '__lookupGetter__', '__lookupSetter__', '__proto__', 'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'valueOf' ]

(Chrome.50):
> Object.getOwnPropertyNames(Object.prototype).sort()
["__defineGetter__", "__defineSetter__", "__lookupGetter__", "__lookupSetter__", "__proto__", "constructor", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "toLocaleString", "toString", "valueOf"]

(Firefox.46):
> Object.getOwnPropertyNames(Object.prototype).sort()
["__defineGetter__", "__defineSetter__", "__lookupGetter__", "__lookupSetter__", "__proto__", "constructor", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "toLocaleString", "toSource", "toString", "unwatch", "valueOf", "watch"]

(Edge.20):
> Object.getOwnPropertyNames(Object.prototype).sort()
["__defineGetter__", "__defineSetter__", "__lookupGetter__", "__lookupSetter__", "__proto__", "constructor", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "toLocaleString", "toString", "valueOf"]

(Safari.5.1.7):
> Object.getOwnPropertyNames(Object.prototype).sort()
["__defineGetter__", "__defineSetter__", "__lookupGetter__", "__lookupSetter__", "constructor", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "toLocaleString", "toString", "valueOf"]

Specific:
* ljb-Object.prototype,
* ljn-ljsObject.prototype,

ljs'Object-function

Description:
Object is the-constructor that contains the-Object.prototype.
It can-create objects: var s = new Object('string');
It contains important names.

Name:
* cpt.ljs'Object,
* cpt.ljs'Object-function,
* cpt.ljsObject,

Whole-chain:
* most-whole-object,

Generic-chain:
* Function.prototype,
* Object.prototype,

Member:
(Chrome.50):
> Object.getOwnPropertyNames(Object).sort()
["arguments", "assign", "caller", "create", "defineProperties", "defineProperty", "freeze", "getOwnPropertyDescriptor", "getOwnPropertyNames", "getOwnPropertySymbols", "getPrototypeOf", "is", "isExtensible", "isFrozen", "isSealed", "keys", "length", "name", "preventExtensions", "prototype", "seal", "setPrototypeOf"]

(Firefox.46):
> Object.getOwnPropertyNames(Object).sort()
[]

(Edge.20):
> Object.getOwnPropertyNames(Object).sort()
[]

(Safari.5.1.7):
> Object.getOwnPropertyNames(Object).sort()
[]

Specific:
* none,

ljsapi'Whole-part-tree

Description:
The-semantic-units of an-api form a-whole-part-tree.
The-ROOT-node of this structure is the-most-whole-object (the-global-object) and contains all others.

Name:
* cpt.ljs'api-whole-part-tree,
* cpt.ljs'whole-part-tree-of-api,
* cpt.ljs'wpt,
* cpt.ljswpt,

Specific:
* ljb-native-whole-part-tree,
* ljn-native-whole-part-tree,

ljsapi'Generic-specific-tree

Description:
The-semantic-units of an-api except of a-whole-part-tree form AND a-generic-specific-tree.
The-ROOT-node of this structure is the-most-generic-object, the-Object.prototype.

Name:
* cpt.ljs'api-generic-specific-tree,
* cpt.ljs'generic-specific-tree-of-api,

Specific:
* ljb-native-generic-specific-tree,
* ljn-native-generic-specific-tree,

ljsapi.SPECIFIC

Specific:
* ljb-API,
* ljn-API,
===
* native-API,
* nativeNo-API,
===
* vanilla-API,
* vanillaNo-API,
===
* library-API,
* program-API,

ljsapi.VANILLA

Descripton:
Vanilla-API is an-API with only native-semantic-units and custom-semantic-units created in one algorithm (no external libraries).

Name:
* cpt.ljs'API.vanilla,
* cpt.ljs'vanilla-API,
* cpt.ljs'plain-API,

ljsalgo'sut.API.NATIVE

Descripton:
Native-API is the-API with only and all the-native-semantic-units.
It has a-whole-part-tree-structure AND a-generic-specific-tree-structure.

Name:
* cpt.ljs'API.native,
* cpt.ljs'native-API,
* cpt.ljs'builtin-API,

Generic:
* ljs-API,

Specific:
* ljb-native-API,
* ljn-native-API,

ljs'Error-function

Description.short:
The Error constructor creates an error object. Instances of Error objects are thrown when runtime errors occur. The Error object can also be used as a base object for user-defined exceptions. See below for standard built-in error types.
Syntax
new Error([message[, fileName[, lineNumber]]])

[https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Error]

Name:
* cpt.ljs'Error-function,
* cpt.ljsError-function,
* cpt.ljs'Error,
* cpt.ljsError,
* Error-cpt,
* Error-function-cpt,

Description:
All JavaScript and System errors raised by Node.js inherit from, or are instances of, the standard JavaScript Error class and are guaranteed to provide at least the properties available on that class.
[https://nodejs.org/docs/v6.3.1/api/errors.html#errors_errors]

Member:
// ljn.6-3-1
// Object.getOwnPropertyNames(Error).sort()
[ 'arguments', 'caller', 'captureStackTrace', 'length', 'name', 'prototype', 'stackTraceLimit' ]
===
// Chrome.52
// Object.getOwnPropertyNames(Error).sort()
["arguments", "caller", "captureStackTrace", "length", "name", "prototype", "stackTraceLimit"]
===
// Firefox.47
// Object.getOwnPropertyNames(Error).sort()
[ "length", "name", "prototype" ]
===
// Edge.25
// Object.getOwnPropertyNames(Error).sort()
["arguments", "caller", length", "name", "prototype", "stackTraceLimit"]

Resource:
* https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Error,
* https://nodejs.org/api/errors.html,

ljs'Math-object

Name:
* cpt.ljs'Math,
* cpt.ljsMath,
* cpt.ljs'Math-object,
* cpt.ljsMath-object,
* cpt.ljso.Math,
* Math-cpt,
* oMath-cpt,

Whole-chain:
* ljs-most-whole-object (global),

ljsMath'Member:
(ljn.6-2-2)
> Object.getOwnPropertyNames(Math).sort()
[ 'E', 'LN10', 'LN2', 'LOG10E', 'LOG2E', 'PI', 'SQRT1_2', 'SQRT2', 'abs', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'clz32', 'cos', 'cosh', 'exp', 'expm1', 'floor', 'fround', 'hypot', 'imul', 'log', 'log10', 'log1p', 'log2', 'max', 'min', 'pow', 'random', 'round', 'sign', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc' ]

(Firefox.47)
> Object.getOwnPropertyNames(Math).sort()
[ 'E', 'LN10', 'LN2', 'LOG10E', 'LOG2E', 'PI', 'SQRT1_2', 'SQRT2', 'abs', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'clz32', 'cos', 'cosh', 'exp', 'expm1', 'floor', 'fround', 'hypot', 'imul', 'log', 'log10', 'log1p', 'log2', 'max', 'min', 'pow', 'random', 'round', 'sign', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'toSource', 'trunc' ]

(Edge.25)
> Object.getOwnPropertyNames(Math).sort()
[ 'E', 'LN10', 'LN2', 'LOG10E', 'LOG2E', 'PI', 'SQRT1_2', 'SQRT2', 'abs', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'clz32', 'cos', 'cosh', 'exp', 'expm1', 'floor', 'fround', 'hypot', 'imul', 'log', 'log10', 'log1p', 'log2', 'max', 'min', 'pow', 'random', 'round', 'sign', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc' ]

ljs'decodeURI-function

Description:
The decodeURI() function decodes a Uniform Resource Identifier (URI) previously created by encodeURI or by a similar routine.
Syntax
decodeURI(encodedURI)

[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURI]

Name:
* cpt.ljs'decodeURI,
* cpt.ljsdecodeURI,
* cpt.ljs'decodeURI-function,

Code.ljs:
> decodeURI('https://el.wikipedia.org/wiki/%CE%91%CE%BB%CE%AD%CE%BA%CE%BF%CF%82_%CE%86%CF%87%CE%BF%CE%BB%CE%BF%CF%82')
< "https://el.wikipedia.org/wiki/Αλέκος_Άχολος"

Resource:

ljsalgo'PHRASE

Description:
Phrases[1] are whole-constructs of semantic-unit NAMES to denote relations of their archetypes that[1] cannot exists autonomously inside the-algorithm.

Name:
* cpt.ljs'phrase,
* cpt.ljsphrase,
* cpt.ljs'semantic-unit-structures,
* cpt.ljssemantic-unit-structures,
* cpt.ljs'sus,
* cpt.ljssus,

Whole-chain:
* ljs-sentence,

Part:
* ljs-semantic-unit,

ljsphrase'Code

Description:
Code-phrase is a-phrase written in code-format.
Examples:
o.member
a[3]
2 + 3
if (b)

Name:
* cpt.ljs'phrase.code,
* cpt.ljsphrase.code,
* cpt.ljs'code-phrase,
* cpt.ljscode-phrase,

ljsalgo'SENTENCE

Description:
Sentences are whole-constructs of semantic-units, ljs-phrases and even other sentences that exists autonomously inside the-algorithm.
The-algorithm is a-whole-part-tree structure of sentences.

Name:
* cpt.ljs'sentence,
* cpt.ljssentence,
* cpt.ljs'statement,
* cpt.ljsstatement,

Whole-chain:
* ljs-program,

Part:
* ljs-ljs-phrase,
* ljs-semantic-unit,

ljsstc'Code

Description:
Code-sentence is a-sentence written in code-format.
Example:
var s = 'string';
n = 2 + 3;
if (b) {//do this};

Name:
* cpt.ljs'sentence.code,
* cpt.ljssentence.code,
* cpt.ljs'code-sentence,
* cpt.ljscode-sentence,

ljsstc.SPECIFIC

SPECIFIC.alphabetically:
* assignment-sentence,
* block-sentence,
* break-sentence,
* creation-sentence,
* conditional-sentence,
* continue-sentence,
* control-sentence,
* definition-sentence,
* delete-sentence,
* do-while-sentence,
* for-sentence,
* generic-sentence,
* genericNo-sentence,
* if-sentence,
* Immediately-invoked-function-expression,
* instance-sentence,
* instanceNo-sentence,
* label-sentence,
* loop-sentence,
* return-sentence,
* simple-sentence,
* simpleNo-sentence,
* switch-sentence,
* while-sentence,

SPECIFIC_DIVISION.instance:
* instance-sentence (genericNo): has no specifics,
* instanceNo-sentence (generic),

SPECIFIC_DIVISION.simple:
* simple-sentence: denotes one relation or doing,
* simpleNo-sentence,

ljsstc.ASSIGNMENT

Description:
Assignment-sentence is a-sentence that puts|assigns a-value in a-name-value-pair.
Code:
n = 3;
s = "text";

Name:
* cpt.ljs'assignment-sentence,
* cpt.ljsassignment-sentence,
* cpt.ljs'assignment-statement,
* cpt.ljsassignment-statement,

ljsstc.BLOCK

Description:
Block-sentence is a-sentence that contains an-order-set of other sentences.
Code:
{
  sentence1;
  sentence2;
  ...
}

Name:
* cpt.ljs'block-sentence,
* cpt.ljsblock-sentence,
* cpt.ljs'block-statement,
* cpt.ljsblock-statement,

ljsstc.DEFINITION

Description:
Definitions are sentences that create instances of semantic-units.
In contrast to natural-languages, machines throw errors if a-sentence uses an undefined semantic-unit!!!

Name:
* cpt.ljs'definition-sentence,
* cpt.ljsdefinition-sentence,
* cpt.ljs'definition-statement,
* cpt.ljsdefinition-statement,
* cpt.ljs'declaration,
* cpt.ljsdeclaration,

Specific:
* function-definition,
* name-value-pair definition,

ljsstc.DEFINITION.FUNCTION

Description:
A-sentence that creates function instance.
Code:
function fName(input-variables) {
  //function body
}

Name:
* cpt.ljs'function-definition-sentence,
* cpt.ljsfunction-definition-sentence,
* cpt.ljs'definition.function,
* cpt.ljsdefinition.function,
* cpt.ljs'function-declaration,
* cpt.ljsfunction-declaration,

ljsstc.DEFINITION.NAME-VALUE-PAIR

Description:
A-sentence that creates a-name-value-pair instance.
Code:
var name;
// === number nvp definition and assignment
var n = 3;
===
const n = 3;
===
let n = 3;

Name:
* cpt.ljs'name-value-pair-definition,
* cpt.ljsname-value-pair-definition,
* cpt.ljs'variable-statement,
* cpt.ljsvariable-statement,
* cpt.ljs'variable-definition-sentence,
* cpt.ljsvariable-definition-sentence,
* cpt.ljs'definition.variable,
* cpt.ljsdefinition.variable,
* cpt.ljs'variable-declaration,
* cpt.ljsvariable-declaration,

ljsalgo'SECTION (scn)

Description:
Ljs-section is a-whole-construct of ljs-sentences.

Name:
* cpt.ljs'section,
* cpt.ljssection,
* ljs'section-cpt,
* ljssection-cpt,

ljsalgo'ROOT-TREE

Description:
Algo-root-tree is the OUTERMOST TREE of an-algorithm, in a-webpage.

Name:
* cpt.ljs'algo-root-tree,
* cpt.ljsalgo-root-tree,
* cpt.ljs-algo-root,

Part:
* the-root-node,
* the-children of the-root-node,

ljsalgo.SPECIFIC

Description:
With the-language programers create many algorithms.
The-quantity depends on the-archetypes known, and the-semantic-units of the-language.

Specific:
* Browser-management,
* Codomain,
* Event-management,
* HML-management,
* Library,
* Math-management,
* Program,
* Time-management,

ljsalgo.CODOMAIN

Description:
An-algorithm is an-INSTANCE of communication.
The-set of all algorithms is the-codomain of the-language.

Name:
* cpt.ljs'codomain,
* cpt.ljscodomain,
* cpt.ljs'domainOut,
* cpt.ljsdomainOut,
* ljscodomain,
* ljscodomainOut,

ljsalgo.LIBRARY

Description:
Algo-library is an-algorithm which can-not-RUN autonomously, but inside another algo.
In other words, a-library HAS-NO an-executing-entry-point, like a-program.
A-library is a-container of NEW semantic-units and so has an-API.

Name:
* cpt.ljs'library,
* cpt.ljs'framework,
* cpt.ljs'plugin,
* cpt.ljslibrary,
* cpt.ljsframework,
* cpt.ljsplugin,
* cpt.ljslbr,
* cpt.ljs'algo.library,
* cpt.ljsalgo.library,
* cpt.ljs-algo-library,
* ljs'library-cpt,

Whole-chain:
* ljs-program,

Part:
* ljs-sentence,

ljslbr'adding

Description:
In ljb you use the-hml-element script.
In ljn with require() because a-library is a-module.

ljslbr.SPECIFIC

Specific:
* ljb-library,
* ljn-library,
===
* vanilla-library,
* vanillaNo-library,

ljslbr.VANILLA

Description:
Vanilla-library is a-library that uses ONLY native-API.

Name:
* cpt.ljs'vanilla-library,
* cpt.ljs'library.vanilla,
* cpt.vanilla-library,
* vanilla-library-cpt,

ljsalgo.PROGRAM

Description:
Ljs-program is an-algorithm which can-RUN autonomously, written in code-format.
In other words, a-program HAS an-executing-entry-point.
A-program is a-container of NEW semantic-units and so has an-API.

Name:
* cpt.ljs'algo-program,
* cpt.ljsalgo-program,
* cpt.ljs-algo-program,
* cpt.ljs'program,
* cpt.ljsprogram,
* ljsprogram-cpt,

Part:
* ljs-library,
* ljs-sentence,

ljspgm'Execution

Description:
Ljs-program-execution is the-process of commanding it to work.
Ljb and ljn programs are-executed very differently.

Name:
* cpt.ljs'program'execution,
* cpt.ljsprogram'execution,
* cpt.ljspgm'call,
* cpt.ljspgm'execution,
* cpt.ljspgm'invocation,
* cpt.ljspgm'open,
* cpt.ljspgm'run,

ljspgm.SPECIFIC

Specific:
* ljb-program,
* ljn-program,

ljsalgo.PACKAGE

Description:
Ljs-package is a-library or a-program PLUS metadata describing the-code.

Name:
* cpt.ljs'package,
* cpt.ljspackage,
* cpt.ljskg,
* ljs'package-cpt,
* ljspackage-cpt,
* ljskg-cpt,

Package-manager:
(linkL)

Specific:
* ljb-package,
* ljn-ljspackage,
===
* bower-package,
* npm-package,

ljs'Binary-code

Description:
The-code is understood by machines indirectly.
Machines directly understand only binary-information.
Therefore, the-code is-translated (with programs) in a-binary-format (binary-code) inside the-machine in order to be-executed.

Name:
* cpt.ljs'binary-code,
* cpt.ljsbinary-code,
* cpt.ljsbcode,

ljs'Evaluation

Name:
* cpt.ljs'evaluation,
* cpt.ljsevaluation,

ljs'Pro

ljs'Simplicity

Its code is-created FROM only 12 semantic-units.

ljs'Inheritance

Javascript-objects do-not-inherit members from other special constructs like 'classes' (like java), but just from other objects.
This simple and powerful characteristic, called 'prototype-based-inheritance' confused programers who knew 'class-based-inheritance'.
Another cause of this confusion is the incorrect use of 'instanceof' by the-language designers.
Also constructor-functions mimic classes, especially with the-new-operator.
I have-created a full desktop browser program, which does-NOT-use a-single custom-constructor!!!
ECMAScript.6.2015 decision to add and classes, is wrong, because it creates an EXTRA semantic-unit, the-class, to implement inheritance[1] which[1] is already implemented with the-prototype-system.
Node.js implementation of 'classes' is-done by creating special functions.

Name:
* cpt.ljs'inheritance,
* cpt.ljsinheritance,

ljs'Con

ljs'Naming-mechanism

Today builtin identifiers do-not-convey information about their values.
Since {2014.08.05}, I am-using valuenames in my code, which makes the-code much more readable.
Also this way we can-have type checking at write-time.

ljs'instanceof

Description:
'Instance' is a-specific-concept with no more specifics.
'My-car' is an-instance of 'car'.
Ljs-objects-created-from-constructors ARE NOT INSTANCES of their constructor.
They are instances of the-Constructor.prototype-object.
THEN the-instanceof operator is a design name-mistake of javascript.
The-confusion came from class-based-languages where the-objects are indeed instances of classes.
objectof is a better name.
Brendan-Eich-tweet

[https://twitter.com/BrendanEich/status/734118379036934144]

ljs'Object-scope

Today, ljs, has only 'function-scope'.
This means, that a-name-value-pair defined inside a-function, can be used all over inside this function.
In other names, the-members of a-function see each other.
We do-not-have this feature inside objects, and to overcome it, we use constructors, or object-returning-functions.
Code-example:
var o = {n1:1, n2:n1} //throws Uncaught ReferenceError
var f=function(){var n1=1; var n2=n1;} //no Error

ljs'Todo

In my opinion ljs needs:
1) Valuenames.
2) Object-scope.
3) No constructors.
Objects could-be-created by functions like Object.create(), functions returning objects, and literal-objects.
The-generic-chain to be: object > objectSpc > objectSpc > ...
And NOT: Object.prototype > Constructor.prototype > Constructor.prototype ...

ljs'Human

Description:
Any human related to the-language.

Name:
* cpt.ljs'human,
* cpt.ljshuman,
* cpt.ljshmn,

ljshmn.Creator

Description:
Creator is any human who contributed in the-creation of the-language.

Name:
* cpt.ljs'creator,
* cpt.ljscreator,

Specific:
* Designer: the-human who created the-spec of the-language,
* Implementor: the-human who created the-code to binary-code translator,

ljshmn.Programer

Description:
Programer is a-human who creates programs.

Name:
* cpt.ljs'programer,
* cpt.ljsprogramer,
* cpt.ljspmr,

ljshmn.User

Description:
User is a-human who uses|runs a-program.

Name:
* cpt.ljs'user,
* cpt.ljsuser,
* cpt.ljsusr,

ljs'Learning

Description:
My goal to write this page, is to help the-learning of the-language from a-linguistic perspective.

My second innovation is the-representation of the-subject.
I am-not-writing down a-bla-bla-text describing the-subject, repeating characteristics here and there.
I am-writing STRUCTURED-CONCEPTS in ONE format.
You can-read the-concept of javascript sequentially OR you can-search for a-characteristic and from there to reach any related concept.

Name:
cpt.ljs'learning,
cpt.ljslearning,

Resource:
* https://developer.mozilla.org/en-US/Learn/JavaScript,
* https://www.codementor.io/learn-javascript-online,

Specific:
* learning-browser-javascript,
* learning-Node-javascript,

ljs'Specification (lje)

Description:
Specification is a-text-document that describes|defines a-language.
ECMA-International creates the-specs for ljb.
ECMA-International creates many standards.
ECMA-262 is the-standard that defines the-ECMAScript-language, as it calls the-ljs.
Specs are-published in pdf or HML format and are texts hard to read and multisemantic.
In current webpage-concept I TRY to describe the-language in monosemantic English by defining most of the-names of my sentences.

Name:
cpt.ECMAScript,
cpt.ljs'specification,
cpt.ljsspecification,
cpt.ljs'spec,
cpt.ljsspec,
cpt.lje,

Specific (versions):
* ECMAScript.6.2015,
* ECMAScript.5-1.2011,
* ECMAScript.5.1999,
* ECMAScript.4 not existing,
* ECMAScript.3.1999,
* ECMAScript.2.1998,
* ECMAScript.1.1997,

lje.ECMAScript.6.2015

Description:
ECMAScript-2015 (6th edition) is the latest version.
Pdf-version.
HML-version.

Name:
* cpt.lje.6.2015,
* cpt.lje.2015.6,
* cpt.ES2015,
* cpt.ECMAScript.6.2015,
* cpt.ECMAScript-2015,
* cpt.ECMA-262-6th-edition,
* cpt.Standard-ECMA-262-6th-edition,

Compatibility:
* compatibility-table, Created by kangax.
* node.green, Node.js compatibility-table, Created by William-Kapke.

lje.ECMAScript.5-1.2011

Description:
ECMAScript-5.1 is the-version previous to ECMAScript.6.2015, approved on {2011.June}.
My html5.id.toc.preview-version.
Pdf-version.
HML-version.

Name:
* cpt.lje.51.2011,
* cpt.lje.2011.51,
* cpt.ECMAScript.51.2011,
* cpt.ECMAScript-5.1,
* cpt.ECMA-262-5.1-edition,
* cpt.Standard-ECMA-262-5.1-edition,

ljs'Tool

Description:
Any program, used to work with the-language, write, execute, debug, analyze, test the-code.
===
Development tools
Within JavaScript, access to a debugger becomes invaluable when developing large, non-trivial programs. Because there can be implementation differences between the various browsers (particularly within the DOM]), it is useful to have access to a debugger for each of the browsers that a Web application targets.

Script debuggers are integrated within Internet Explorer, Firefox, Safari, Google Chrome, Opera and Node.js.

In addition to the native Internet Explorer Developer Tools, three debuggers are available for Internet Explorer: Microsoft Visual Studio is the richest of the three, closely followed by Microsoft Script Editor (a component of Microsoft Office), and finally the free Microsoft Script Debugger that is far more basic than the other two. The free Microsoft Visual Web Developer Express provides a limited version of the JavaScript debugging functionality in Microsoft Visual Studio. Internet Explorer has included developer tools since version 8.

In comparison to Internet Explorer, Firefox has a more comprehensive set of developer tools, which include a debugger as well. Old versions of Firefox without these tools used a Firefox addon called Firebug, or the older Venkman debugger. Also, WebKit's Web Inspector includes a JavaScript debugger, which is used in Safari. A modified version called Blink DevTools is used in Google Chrome. Node.js has Node Inspector, an interactive debugger that integrates with the Blink DevTools, available in Google Chrome. Last but not least, Opera includes a set of tools called Dragonfly.

In addition to the native computer software, there are online JavaScript IDEs, debugging aids are themselves written in JavaScript and built to run on the Web. An example is the program JSLint, developed by Douglas Crockford who has written extensively on the language. JSLint scans JavaScript code for conformance to a set of standards and guidelines. Many libraries for JavaScript, such as three.js, provide links to demonstration code that can be edited by users. They are also used as a pedagogical tool by institutions such as Khan Academy to allow students to experience writing code in an environment where they can see the output of their programs, without needing any setup beyond a Web browser.

[https://en.wikipedia.org/wiki/JavaScript#Development_tools {2016.08.08}]

Name:
* cpt.ljs'development-tool,
* cpt.ljs'programing-tool,
* cpt.ljs'tool,
* cpt.ljstool,

Specific:
* build-tool,
* code-analysis-tool,
* debugger-tool,
* editor-tool,
* interpreter-(runtime)-tool,
* package-manager,
* testing-tool,
===
* ljb-tool,
* ljn-tool,

ljstool.ENGINE

Description:
A JavaScript engine is a program or library which executes JavaScript code.
A JavaScript engine may be a traditional interpreter, or it may utilize just-in-time compilation to bytecode in some manner.
Although there are several uses for a JavaScript engine, it is most commonly used in web browsers.

[https://en.wikipedia.org/wiki/JavaScript_engine {2016.07.25}]

Name:
* cpt.ljs'tool.engine,
* cpt.ljs'ljs-engine,
* cpt.ljs'ljs-interpreter,
* cpt.ljs'ljs-runtime,
* cpt.ljs'javascript-engine,

Specific:
* browser-engine,
* browserNo-engine,
* Node.js-engine,
* Google-V8-engine,

ljstool.engine.V8

Description:
V8 is Google's open source high-performance JavaScript engine, written in C++ and used in Google Chrome, the open source browser from Google.
It implements ECMAScript as specified in ECMA-262, and runs on Windows XP or later, Mac OS X 10.5+, and Linux systems that use IA-32, ARM or MIPS processors.
V8 can run standalone, or can be embedded into any C++ application.

[https://github.com/v8/v8/wiki]

Name:
* cpt.ljs'v8,
* cpt.ljs'Google-V8-engine,
* cpt.ljs'Google-V8-javascript-engine,

ljstool.PACKAGE-MANAGER

Description:
Understanding JavaScript Package Managers
There are several JavaScript package managers: npm, bower, volo, ringojs, component. Currently, npm and bower have the most registered packages and enjoy the broadest third-party support.

Npm deals mainly in node-compatible JavaScript modules. However, bower focuses on the entire web platform, offering packages that could contain modules, scripts, CSS stylesheets, HTML templates, images, or fonts. For these reasons, npm tends to be used primarily for node.js development, and bower tends to be the favorite for client-side work.

While npm and bower use incompatible organizational patterns, both may be used in a single project since they use different metadata files (package.json and bower.json), and they install packages into different subdirectories. It's not uncommon to use npm to manage server-side packages and bower to manage client-side packages.

Unlike Java's Maven, JavaScript package managers concentrate mainly on finding packages, installing packages, and managing package versions. Npm also offers the ability to run simple build-related and test-related tasks.

Using JavaScript package managers
Getting started with package managers is straightforward. The following examples are for bower and npm, but similar concepts exist for the others.

After installing bower or npm, type bower init or npm init at the root directory of your project. The package manager will ask several questions. Your answers will be used to create a bower.json or package.json metadata file for your project.

To search for available packages to install, type bower search 'keywords' or npm search 'keywords'. A list of matching packages will be displayed.

To install a package into the local module cache and then copy its latest version into your project, type bower install 'package-name' or npm install 'package-name'. To install a specific version, the syntax varies slightly amongst package managers: bower install 'package-name'#'package-version' or npm install 'package-name'@'package-version'.

You may also save each package's version info into your project's metadata file. The package manager -- as well as other third-party tools -- can use the metadata to simplify client-side maintenance, build, testing, and bootstrapping tasks.

The best way to save a package's version info into your project's metadata file, is to use the --save option while installing the package. Type bower install --save 'package-name'#'package-version' or npm install --save 'package-name'@'package-version'.

[https://spring.io/understanding/javascript-package-managers]

Name:
* cpt.ljs'tool.package-manager,
* cpt.ljs'package-manager,
* ljs'tool.package-manager-cpt,
* ljs'package-manager-cpt,
* package-manager-cpt,

ljspkgmgr.SPECIFIC

Specific:
* bower-package-manager,
* npm-package-manager,

ljs'tool.TESTING

Description:
JavaScript doesn't support testing natively.

Name:
* cpt.ljs'tool.testing,
* cpt.ljs'testing-tool,
* ljs'tool.testing-cpt,
* ljs'testing-tool-cpt,

Resource:
* https://www.sitepoint.com/javascript-testing-unit-functional-integration/ {2016.04.25},
* https://github.com/jasmine/jasmine,

Specific:
* ljb-testing-tool,
* ljn-testing-tool,

ljs.SPECIFIC

Name:
cpt.ljs.specific,
cpt.ljs'dialect,
cpt.ljsdialect,

Description:
A-javascript-dialect is a-programing-language with most of the-characteristics of ljs, that a-programer 'speaks' and a-computer 'understands'.
If there is no a-compiler|interpreter there is no programing-language.
Today our theories about the-languages (human or computer) are incorrect to a significant extent, but the-languages exist before our theories about them.
ECMAScript, from this point of view, is not a-language, it is a-theory about ljs.

Specific:
* Browser-javascript,
* BrowserNo-javascript,
* Node-javascript,
* Server-javascript,
* ServerNo-javascript,
* Strict-javascript,
* StrictNo-javascript,

ljs.Browser-javascript (ljb) {1995}

ljb'Description

Description:
Browser-javascript (ljb) is the-programing-language of webpages, the-language which the-web-browsers know, the so called client-side-javascript.

ljb'Name

Name:
* cpt.browser-javascript,
* cpt.browser-javascript-language,
* cpt.browser-javascript-programing-language,
* cpt.client-side-javascript,
* cpt.front-end-javascript,
* cpt.JavaScript,
* cpt.jsb,
* cpt.langJsb,
* cpt.lngJsb,
* cpt.ljb,
* cpt.language.javascript.browser,
* cpt.programing-language.javascript.browser,
* browser-javascript-cpt,
* client-side-javascript-cpt,
* front-end-javascript-cpt,

ljb'Generic-chain

Generic-chain:
* javascript-programing-language,
* programing-language,
* computer-language,
* mapping-method,
* method,
* info,
* model,
* entity,

ljb'Archetype

Description:
Ljb-archetype is the-information the-ljb maps.
Ljb-archetype is mainly HML and CSS code with which webpages are-created as well numbers and human-text.

Name:
* cpt.ljb'archetype-information,
* cpt.ljbarchetype-information,
* cpt.ljb'archo,
* cpt.ljbarcho,
* cpt.ljb'arc,
* cpt.ljbarc,

Generic-chain:
* ljs-archetype,

ljbarcho'HML

todo

ljbarcho'CSS

todo

ljbarcho.Domain

Description:
An-archetype is an-INSTANCE of communication.
The-set of all archetypes is the-domain of the-language.

Name:
* cpt.ljb'domain,
* cpt.ljbdomain,
* cpt.ljb'domainIn,
* cpt.ljbdomainIn,
* ljbdomain-cpt,

ljb'Algorithm (Model)

Generic:
* ljs-algorithm,

Name:
* cpt.ljb'algorithm,
* cpt.ljbalgorithm,
* cpt.ljb'algo,
* cpt.ljbalgo,
* cpt.ljb'model,
* cpt.ljbmodel,
* cpt.ljb'alg,
* cpt.ljbalg,
* cpt.ljb'doc,
* cpt.ljbdoc,

ljbalgo'Code

Generic:
* ljs-code,

Name:
* cpt.ljb'code,
* cpt.ljbcode,
* cpt.ljb'code-format,
* cpt.ljb'code-format,
* cpt.ljbsource-code,
* cpt.ljb'cod,
* cpt.ljbcod,

ljbalgo'Browser-compatibility

Description:
"Εverything flows", the-language and the-browsers.
We need to know, if the-algorithm we constructed is supported by the-browser we use to execute it.

Name:
* cpt.ljb'browser-compatibility,
* cpt.ljbbrowser-compatibility,
* cpt.ljb'browser-support,
* cpt.ljbbrowser-support,

ljbalgo'UNIT

Generic:
* ljs-unit,

Name:
* cpt.ljb'unit,
* cpt.ljbunit,

ljbalgo'WORD

Generic:
* ljs-word,

Name:
* cpt.ljb'word,
* cpt.ljbword,

ljbalgo'SEMANTIC-UNIT (sut)

Generic:
* ljs-semantic-unit,

Name:
* cpt.ljb'semantic-unit,
* cpt.ljbsemantic-unit,
* cpt.ljb'unit.semantic,
* cpt.ljbunit.semantic,
* cpt.ljb'sut,
* cpt.ljbsut,
* cpt.ljb'sunit,
* cpt.ljbsunit,
* cpt.ljb'untSmc,
* cpt.ljbuntSmc,

Whole-chain:
=== (syntax-wptree)
* ljb-phrase,
* ljb-sentence,
* ljb-library,
* ljb-program,
=== (API-wptree)
* another semantic-unit,
...
* window,

ljbalgo'sut.SPECIFIC

Specific:
Ljb uses only 11 semantic-units to create an-algorithm:
01) a - Array,
02) b - Boolean,
03) f - Function,
04) l - nuLl,
05) n - Number,
06) o - Object,
07) r - Regexp,
08) s - String,
09) u - Undefined,
10) v - name-Value-pair,
11) x - miXed,

Specific.alphabetically:
* array--semantic-unit,
* boolean--semantic-unit,
* custom--semantic-unit,
* customNo--semantic-unit,
* function--semantic-unit,
* name-semantic-unit,
* nameNo-semantic-unit,
* name-value-pair-mixed--semantic-unit,
* name-value-pair-mixedNo--semantic-unit,
* name-value-pair-No--semantic-unit,
* null--semantic-unit,
* number--semantic-unit,
* object--semantic-unit,
* objectNo--semantic-unit,
* regexp--semantic-unit,
* string--semantic-unit,
* undefined--semantic-unit,

ljbalgo'sut.ARRAY (ljba)

Generic:
* ljs-array,

Name:
* cpt.ljb'array,
* cpt.ljbarray,
* cpt.ljba,

ljbalgo'sut.BOOLEAN (ljbb)

Generic:
* ljs-boolean,

Name:
* cpt.ljb'boolean,
* cpt.ljbboolean,
* cpt.ljbb,
* ljbboolean-cpt,
* ljbb-cpt,

ljbalgo'sut.FUNCTION (ljbf)

Generic:
* ljs-function,

Name:
* cpt.ljb'function,
* cpt.ljbfunction,
* cpt.ljbf,
* ljbfunction-cpt,
* ljbf-cpt,

ljbf.SPECIFIC

Specific.alphabetically:
* constructor-function,
* custom-function,
* customNo-function,
* method-function,
* methodNo-function,
* object-returning-function,
* operator-function,
* self-executing-function,

Specific.BUILTIN.Chrome.50:

  1. AnimationEvent
  2. AppBannerPromptResult
  3. ApplicationCache
  4. ApplicationCacheErrorEvent
  5. Array
  6. ArrayBuffer
  7. Attr
  8. Audio
  9. AudioBuffer
  10. AudioBufferSourceNode
  11. AudioContext
  12. AudioDestinationNode
  13. AudioListener
  14. AudioNode
  15. AudioParam
  16. AudioProcessingEvent
  17. AutocompleteErrorEvent
  18. BarProp
  19. BatteryManager
  20. BeforeInstallPromptEvent
  21. BeforeUnloadEvent
  22. BiquadFilterNode
  23. Blob
  24. BlobEvent
  25. Boolean
  26. CDATASection
  27. CSS
  28. CSSFontFaceRule
  29. CSSGroupingRule
  30. CSSImportRule
  31. CSSKeyframeRule
  32. CSSKeyframesRule
  33. CSSMediaRule
  34. CSSNamespaceRule
  35. CSSPageRule
  36. CSSRule
  37. CSSRuleList
  38. CSSStyleDeclaration
  39. CSSStyleRule
  40. CSSStyleSheet
  41. CSSSupportsRule
  42. CSSViewportRule
  43. Cache
  44. CacheStorage
  45. CanvasGradient
  46. CanvasPattern
  47. CanvasRenderingContext2D
  48. ChannelMergerNode
  49. ChannelSplitterNode
  50. CharacterData
  51. ClientRect
  52. ClientRectList
  53. ClipboardEvent
  54. CloseEvent
  55. Comment
  56. CompositionEvent
  57. ConvolverNode
  58. Crypto
  59. CryptoKey
  60. CustomEvent
  61. DOMError
  62. DOMException
  63. DOMImplementation
  64. DOMParser
  65. DOMStringList
  66. DOMStringMap
  67. DOMTokenList
  68. DataTransfer
  69. DataTransferItem
  70. DataTransferItemList
  71. DataView
  72. Date
  73. DelayNode
  74. DeviceMotionEvent
  75. DeviceOrientationEvent
  76. Document
  77. DocumentFragment
  78. DocumentType
  79. DragEvent
  80. DynamicsCompressorNode
  81. Element
  82. Error
  83. ErrorEvent
  84. EvalError
  85. Event
  86. EventSource
  87. EventTarget
  88. File
  89. FileError
  90. FileList
  91. FileReader
  92. Float32Array
  93. Float64Array
  94. FocusEvent
  95. FontFace
  96. FormData
  97. Function
  98. GainNode
  99. Gamepad
  100. GamepadButton
  101. GamepadEvent
  102. HTMLAllCollection
  103. HTMLAnchorElement
  104. HTMLAreaElement
  105. HTMLAudioElement
  106. HTMLBRElement
  107. HTMLBaseElement
  108. HTMLBodyElement
  109. HTMLButtonElement
  110. HTMLCanvasElement
  111. HTMLCollection
  112. HTMLContentElement
  113. HTMLDListElement
  114. HTMLDataListElement
  115. HTMLDetailsElement
  116. HTMLDialogElement
  117. HTMLDirectoryElement
  118. HTMLDivElement
  119. HTMLDocument
  120. HTMLElement
  121. HTMLEmbedElement
  122. HTMLFieldSetElement
  123. HTMLFontElement
  124. HTMLFormControlsCollection
  125. HTMLFormElement
  126. HTMLFrameElement
  127. HTMLFrameSetElement
  128. HTMLHRElement
  129. HTMLHeadElement
  130. HTMLHeadingElement
  131. HTMLHtmlElement
  132. HTMLIFrameElement
  133. HTMLImageElement
  134. HTMLInputElement
  135. HTMLKeygenElement
  136. HTMLLIElement
  137. HTMLLabelElement
  138. HTMLLegendElement
  139. HTMLLinkElement
  140. HTMLMapElement
  141. HTMLMarqueeElement
  142. HTMLMediaElement
  143. HTMLMenuElement
  144. HTMLMetaElement
  145. HTMLMeterElement
  146. HTMLModElement
  147. HTMLOListElement
  148. HTMLObjectElement
  149. HTMLOptGroupElement
  150. HTMLOptionElement
  151. HTMLOptionsCollection
  152. HTMLOutputElement
  153. HTMLParagraphElement
  154. HTMLParamElement
  155. HTMLPictureElement
  156. HTMLPreElement
  157. HTMLProgressElement
  158. HTMLQuoteElement
  159. HTMLScriptElement
  160. HTMLSelectElement
  161. HTMLShadowElement
  162. HTMLSourceElement
  163. HTMLSpanElement
  164. HTMLStyleElement
  165. HTMLTableCaptionElement
  166. HTMLTableCellElement
  167. HTMLTableColElement
  168. HTMLTableElement
  169. HTMLTableRowElement
  170. HTMLTableSectionElement
  171. HTMLTemplateElement
  172. HTMLTextAreaElement
  173. HTMLTitleElement
  174. HTMLTrackElement
  175. HTMLUListElement
  176. HTMLUnknownElement
  177. HTMLVideoElement
  178. HashChangeEvent
  179. Headers
  180. History
  181. IDBCursor
  182. IDBCursorWithValue
  183. IDBDatabase
  184. IDBFactory
  185. IDBIndex
  186. IDBKeyRange
  187. IDBObjectStore
  188. IDBOpenDBRequest
  189. IDBRequest
  190. IDBTransaction
  191. IDBVersionChangeEvent
  192. IIRFilterNode
  193. IdleDeadline
  194. Image
  195. ImageBitmap
  196. ImageData
  197. Infinity
  198. InputDeviceCapabilities
  199. Int16Array
  200. Int32Array
  201. Int8Array
  202. Intl
  203. JSON
  204. KeyboardEvent
  205. Location
  206. MIDIAccess
  207. MIDIConnectionEvent
  208. MIDIInput
  209. MIDIInputMap
  210. MIDIMessageEvent
  211. MIDIOutput
  212. MIDIOutputMap
  213. MIDIPort
  214. Map
  215. MediaDevices
  216. MediaElementAudioSourceNode
  217. MediaEncryptedEvent
  218. MediaError
  219. MediaKeyMessageEvent
  220. MediaKeySession
  221. MediaKeyStatusMap
  222. MediaKeySystemAccess
  223. MediaKeys
  224. MediaList
  225. MediaQueryList
  226. MediaQueryListEvent
  227. MediaRecorder
  228. MediaSource
  229. MediaStreamAudioDestinationNode
  230. MediaStreamAudioSourceNode
  231. MediaStreamEvent
  232. MediaStreamTrack
  233. MessageChannel
  234. MessageEvent
  235. MessagePort
  236. MimeType
  237. MimeTypeArray
  238. MouseEvent
  239. MutationEvent
  240. MutationObserver
  241. MutationRecord
  242. NaN
  243. NamedNodeMap
  244. Navigator
  245. Node
  246. NodeFilter
  247. NodeIterator
  248. NodeList
  249. Notification
  250. Number
  251. Object
  252. OfflineAudioCompletionEvent
  253. OfflineAudioContext
  254. Option
  255. OscillatorNode
  256. PageTransitionEvent
  257. Path2D
  258. Performance
  259. PerformanceEntry
  260. PerformanceMark
  261. PerformanceMeasure
  262. PerformanceNavigation
  263. PerformanceResourceTiming
  264. PerformanceTiming
  265. PeriodicWave
  266. PermissionStatus
  267. Permissions
  268. Plugin
  269. PluginArray
  270. PopStateEvent
  271. Presentation
  272. PresentationAvailability
  273. PresentationConnection
  274. PresentationConnectionAvailableEvent
  275. PresentationConnectionCloseEvent
  276. PresentationRequest
  277. ProcessingInstruction
  278. ProgressEvent
  279. Promise
  280. PromiseRejectionEvent
  281. Proxy
  282. PushManager
  283. PushSubscription
  284. RTCCertificate
  285. RTCIceCandidate
  286. RTCSessionDescription
  287. RadioNodeList
  288. Range
  289. RangeError
  290. ReadableByteStream
  291. ReadableStream
  292. ReferenceError
  293. Reflect
  294. RegExp
  295. Request
  296. Response
  297. SVGAElement
  298. SVGAngle
  299. SVGAnimateElement
  300. SVGAnimateMotionElement
  301. SVGAnimateTransformElement
  302. SVGAnimatedAngle
  303. SVGAnimatedBoolean
  304. SVGAnimatedEnumeration
  305. SVGAnimatedInteger
  306. SVGAnimatedLength
  307. SVGAnimatedLengthList
  308. SVGAnimatedNumber
  309. SVGAnimatedNumberList
  310. SVGAnimatedPreserveAspectRatio
  311. SVGAnimatedRect
  312. SVGAnimatedString
  313. SVGAnimatedTransformList
  314. SVGAnimationElement
  315. SVGCircleElement
  316. SVGClipPathElement
  317. SVGComponentTransferFunctionElement
  318. SVGCursorElement
  319. SVGDefsElement
  320. SVGDescElement
  321. SVGDiscardElement
  322. SVGElement
  323. SVGEllipseElement
  324. SVGFEBlendElement
  325. SVGFEColorMatrixElement
  326. SVGFEComponentTransferElement
  327. SVGFECompositeElement
  328. SVGFEConvolveMatrixElement
  329. SVGFEDiffuseLightingElement
  330. SVGFEDisplacementMapElement
  331. SVGFEDistantLightElement
  332. SVGFEDropShadowElement
  333. SVGFEFloodElement
  334. SVGFEFuncAElement
  335. SVGFEFuncBElement
  336. SVGFEFuncGElement
  337. SVGFEFuncRElement
  338. SVGFEGaussianBlurElement
  339. SVGFEImageElement
  340. SVGFEMergeElement
  341. SVGFEMergeNodeElement
  342. SVGFEMorphologyElement
  343. SVGFEOffsetElement
  344. SVGFEPointLightElement
  345. SVGFESpecularLightingElement
  346. SVGFESpotLightElement
  347. SVGFETileElement
  348. SVGFETurbulenceElement
  349. SVGFilterElement
  350. SVGForeignObjectElement
  351. SVGGElement
  352. SVGGeometryElement
  353. SVGGradientElement
  354. SVGGraphicsElement
  355. SVGImageElement
  356. SVGLength
  357. SVGLengthList
  358. SVGLineElement
  359. SVGLinearGradientElement
  360. SVGMPathElement
  361. SVGMarkerElement
  362. SVGMaskElement
  363. SVGMatrix
  364. SVGMetadataElement
  365. SVGNumber
  366. SVGNumberList
  367. SVGPathElement
  368. SVGPatternElement
  369. SVGPoint
  370. SVGPointList
  371. SVGPolygonElement
  372. SVGPolylineElement
  373. SVGPreserveAspectRatio
  374. SVGRadialGradientElement
  375. SVGRect
  376. SVGRectElement
  377. SVGSVGElement
  378. SVGScriptElement
  379. SVGSetElement
  380. SVGStopElement
  381. SVGStringList
  382. SVGStyleElement
  383. SVGSwitchElement
  384. SVGSymbolElement
  385. SVGTSpanElement
  386. SVGTextContentElement
  387. SVGTextElement
  388. SVGTextPathElement
  389. SVGTextPositioningElement
  390. SVGTitleElement
  391. SVGTransform
  392. SVGTransformList
  393. SVGUnitTypes
  394. SVGUseElement
  395. SVGViewElement
  396. SVGViewSpec
  397. SVGZoomEvent
  398. Screen
  399. ScreenOrientation
  400. ScriptProcessorNode
  401. SecurityPolicyViolationEvent
  402. Selection
  403. ServiceWorker
  404. ServiceWorkerContainer
  405. ServiceWorkerMessageEvent
  406. ServiceWorkerRegistration
  407. Set
  408. ShadowRoot
  409. SharedWorker
  410. SourceBuffer
  411. SourceBufferList
  412. SpeechSynthesisEvent
  413. SpeechSynthesisUtterance
  414. Storage
  415. StorageEvent
  416. String
  417. StyleSheet
  418. StyleSheetList
  419. SubtleCrypto
  420. Symbol
  421. SyncManager
  422. SyntaxError
  423. Text
  424. TextDecoder
  425. TextEncoder
  426. TextEvent
  427. TextMetrics
  428. TextTrack
  429. TextTrackCue
  430. TextTrackCueList
  431. TextTrackList
  432. TimeRanges
  433. Touch
  434. TouchEvent
  435. TouchList
  436. TrackEvent
  437. TransitionEvent
  438. TreeWalker
  439. TypeError
  440. UIEvent
  441. URIError
  442. URL
  443. URLSearchParams
  444. Uint16Array
  445. Uint32Array
  446. Uint8Array
  447. Uint8ClampedArray
  448. VTTCue
  449. ValidityState
  450. WaveShaperNode
  451. WeakMap
  452. WeakSet
  453. WebGLActiveInfo
  454. WebGLBuffer
  455. WebGLContextEvent
  456. WebGLFramebuffer
  457. WebGLProgram
  458. WebGLRenderbuffer
  459. WebGLRenderingContext
  460. WebGLShader
  461. WebGLShaderPrecisionFormat
  462. WebGLTexture
  463. WebGLUniformLocation
  464. WebKitAnimationEvent
  465. WebKitCSSMatrix
  466. WebKitMutationObserver
  467. WebKitTransitionEvent
  468. WebSocket
  469. WheelEvent
  470. Window
  471. Worker
  472. XMLDocument
  473. XMLHttpRequest
  474. XMLHttpRequestEventTarget
  475. XMLHttpRequestUpload
  476. XMLSerializer
  477. XPathEvaluator
  478. XPathExpression
  479. XPathResult
  480. XSLTProcessor

ljbalgo'sut.NULL (ljbl)

Generic:
* ljs-null,

Name:
* cpt.ljb'null,
* cpt.ljbnull,
* cpt.ljbl,
* ljbnull-cpt,
* ljbl-cpt,

ljbalgo'sut.NUMBER (ljbn)

Generic:
* ljs-number,

Name:
* cpt.ljb'number,
* cpt.ljbnumber,
* cpt.ljbn,
* ljbn-cpt,

ljbalgo'sut.OBJECT (ljbo)

Generic:
* ljs-object,

Name:
* cpt.ljb'object,
* cpt.ljbobject,
* cpt.ljbo,
* ljbobject-cpt,
* ljbo-cpt,

ljbo.SPECIFIC

Specific.alphabetically:
* constructor-object,
* constructorNo-object,
* custom-object,
* customNo-object,
* most-whole-object (global),
* first-class-object,
* first-class-no-object,
* literal-object,
* literalNo-object,
* Object.prototype,

ljbalgo'sut.REGEXP (ljbr)

Generic:
* ljs-regexp,

Name:
* cpt.ljb'regexp,
* cpt.ljbregexp,
* cpt.ljbr,
* ljbregexp-cpt,
* ljbr-cpt,

ljbalgo'sut.STRING (ljbs)

Generic:
* ljs-string,

Name:
* cpt.ljb'string,
* cpt.ljbstring,
* cpt.ljbs,
* ljbstring-cpt,
* ljbs-cpt,

ljbalgo'sut.UNDEFINED (ljbu)

Generic:
* ljs-undefined,

Name:
* cpt.ljb'undefined,
* cpt.ljbundefined,
* cpt.ljbu,
* ljbundefined-cpt,
* ljbu-cpt,

ljbalgo'sut.NAME-VALUE-PAIR (ljbv)

Generic:
* ljs-name-value-pair,

Name:
* cpt.ljb'name-semantic-unit,
* cpt.ljb'named-semantic-unit,
* cpt.ljb'name-value-pair,
* cpt.ljbname-value-pair,
* cpt.ljbnvp,
* cpt.ljb'variable,
* cpt.ljbvariable,
* ljbname-value-pair-cpt,
* ljbvariable-cpt,

ljbalgo'sut.MIXED (ljbx)

Generic:
* ljs-mixed-semantic-unit,

Name:
* cpt.ljb'mixed,
* cpt.ljbmixed,
* cpt.ljbx,
* ljbmixed-cpt,
* ljbx-cpt,

ljbalgo'sut.API

Generic:
* ljs-API,

Name:
* cpt.ljb'API,
* cpt.ljbAPI,
* ljb'API-cpt,

Description:
* whole-part-tree-of-ljb-native-API,
* generic-specific-tree-of-ljb-native-API,

ljbalgo'sut.API.NATIVE

Generic:
* ljs-native-API,

Name:
* cpt.ljb'API.native,
* cpt.ljb'native-API,

ljbapiNtv'WHOLE-PART-TREE

Description:
An-API is structured (from one point of view) in a-whole-part tree.
window is the-most-whole-object, the-root, the-global-object, of the-ljb native-API.

Name:
* cpt.ljb'API's-whole-part-tree,
* cpt.ljbAPI's-whole-part-tree,
* cpt.ljb'object-whole-part-tree,
* cpt.ljbobject-whole-part-tree,
* cpt.ljb'wpt,
* cpt.ljbwpt,

ljbapiNtv'whole-part-tree.Chrome

Chrome.50.2016-05-09 native-API-whole-part-tree:
(≅700 semantic-units)

  • window (ROOT of whole-part-tree)
    • AnalyserNode
    • AnimationEvent
    • AppBannerPromptResult
    • ApplicationCache
    • ApplicationCacheErrorEvent
    • Array
      • arguments
      • caller
      • from
      • isArray
      • length
      • name
      • of
      • prototype
    • ArrayBuffer
    • Attr
    • Audio
    • AudioBuffer
    • AudioBufferSourceNode
    • AudioContext
    • AudioDestinationNode
    • AudioListener
    • AudioNode
    • AudioParam
    • AudioProcessingEvent
    • AutocompleteErrorEvent
    • BarProp
    • BatteryManager
    • BeforeInstallPromptEvent
    • BeforeUnloadEvent
    • BiquadFilterNode
    • Blob
    • BlobEvent
    • Boolean
    • CDATASection
    • CSS
    • CSSFontFaceRule
    • CSSGroupingRule
    • CSSImportRule
    • CSSKeyframeRule
    • CSSKeyframesRule
    • CSSMediaRule
    • CSSNamespaceRule
    • CSSPageRule
    • CSSRule
    • CSSRuleList
    • CSSStyleDeclaration
    • CSSStyleRule
    • CSSStyleSheet
    • CSSSupportsRule
    • CSSViewportRule
    • Cache
    • CacheStorage
    • CanvasGradient
    • CanvasPattern
    • CanvasRenderingContext2D
    • ChannelMergerNode
    • ChannelSplitterNode
    • CharacterData
    • ClientRect
    • ClientRectList
    • ClipboardEvent
    • CloseEvent
    • Comment
    • CompositionEvent
    • ConvolverNode
    • Crypto
    • CryptoKey
    • CustomEvent
    • DOMError
    • DOMException
    • DOMImplementation
    • DOMParser
    • DOMStringList
    • DOMStringMap
    • DOMTokenList
    • DataTransfer
    • DataTransferItem
    • DataTransferItemList
    • DataView
    • Date
    • DelayNode
    • DeviceMotionEvent
    • DeviceOrientationEvent
    • Document
    • DocumentFragment
    • DocumentType
    • DragEvent
    • DynamicsCompressorNode
    • Element
    • Error
    • ErrorEvent
    • EvalError
    • Event
    • EventSource
    • EventTarget
    • File
    • FileError
    • FileList
    • FileReader
    • Float32Array
    • Float64Array
    • FocusEvent
    • FontFace
    • FormData
    • Function
    • GainNode
    • Gamepad
    • GamepadButton
    • GamepadEvent
    • HTMLAllCollection
    • HTMLAnchorElement
    • HTMLAreaElement
    • HTMLAudioElement
    • HTMLBRElement
    • HTMLBaseElement
    • HTMLBodyElement
    • HTMLButtonElement
    • HTMLCanvasElement
    • HTMLCollection
    • HTMLContentElement
    • HTMLDListElement
    • HTMLDataListElement
    • HTMLDetailsElement
    • HTMLDialogElement
    • HTMLDirectoryElement
    • HTMLDivElement
    • HTMLDocument
    • HTMLElement
    • HTMLEmbedElement
    • HTMLFieldSetElement
    • HTMLFontElement
    • HTMLFormControlsCollection
    • HTMLFormElement
    • HTMLFrameElement
    • HTMLFrameSetElement
    • HTMLHRElement
    • HTMLHeadElement
    • HTMLHeadingElement
    • HTMLHtmlElement
    • HTMLIFrameElement
    • HTMLImageElement
    • HTMLInputElement
    • HTMLKeygenElement
    • HTMLLIElement
    • HTMLLabelElement
    • HTMLLegendElement
    • HTMLLinkElement
    • HTMLMapElement
    • HTMLMarqueeElement
    • HTMLMediaElement
    • HTMLMenuElement
    • HTMLMetaElement
    • HTMLMeterElement
    • HTMLModElement
    • HTMLOListElement
    • HTMLObjectElement
    • HTMLOptGroupElement
    • HTMLOptionElement
    • HTMLOptionsCollection
    • HTMLOutputElement
    • HTMLParagraphElement
    • HTMLParamElement
    • HTMLPictureElement
    • HTMLPreElement
    • HTMLProgressElement
    • HTMLQuoteElement
    • HTMLScriptElement
    • HTMLSelectElement
    • HTMLShadowElement
    • HTMLSourceElement
    • HTMLSpanElement
    • HTMLStyleElement
    • HTMLTableCaptionElement
    • HTMLTableCellElement
    • HTMLTableColElement
    • HTMLTableElement
    • HTMLTableRowElement
    • HTMLTableSectionElement
    • HTMLTemplateElement
    • HTMLTextAreaElement
    • HTMLTitleElement
    • HTMLTrackElement
    • HTMLUListElement
    • HTMLUnknownElement
    • HTMLVideoElement
    • HashChangeEvent
    • Headers
    • History
    • IDBCursor
    • IDBCursorWithValue
    • IDBDatabase
    • IDBFactory
    • IDBIndex
    • IDBKeyRange
    • IDBObjectStore
    • IDBOpenDBRequest
    • IDBRequest
    • IDBTransaction
    • IDBVersionChangeEvent
    • IIRFilterNode
    • IdleDeadline
    • Image
    • ImageBitmap
    • ImageData
    • Infinity
    • InputDeviceCapabilities
    • Int16Array
    • Int32Array
    • Int8Array
    • Intl
    • JSON
    • KeyboardEvent
    • Location
    • MIDIAccess
    • MIDIConnectionEvent
    • MIDIInput
    • MIDIInputMap
    • MIDIMessageEvent
    • MIDIOutput
    • MIDIOutputMap
    • MIDIPort
    • Map
    • Math
    • MediaDevices
    • MediaElementAudioSourceNode
    • MediaEncryptedEvent
    • MediaError
    • MediaKeyMessageEvent
    • MediaKeySession
    • MediaKeyStatusMap
    • MediaKeySystemAccess
    • MediaKeys
    • MediaList
    • MediaQueryList
    • MediaQueryListEvent
    • MediaRecorder
    • MediaSource
    • MediaStreamAudioDestinationNode
    • MediaStreamAudioSourceNode
    • MediaStreamEvent
    • MediaStreamTrack
    • MessageChannel
    • MessageEvent
    • MessagePort
    • MimeType
    • MimeTypeArray
    • MouseEvent
    • MutationEvent
    • MutationObserver
    • MutationRecord
    • NaN
    • NamedNodeMap
    • Navigator
    • Node
    • NodeFilter
    • NodeIterator
    • NodeList
    • Notification
    • Number
    • Object
    • OfflineAudioCompletionEvent
    • OfflineAudioContext
    • Option
    • OscillatorNode
    • PageTransitionEvent
    • Path2D
    • Performance
    • PerformanceEntry
    • PerformanceMark
    • PerformanceMeasure
    • PerformanceNavigation
    • PerformanceResourceTiming
    • PerformanceTiming
    • PeriodicWave
    • PermissionStatus
    • Permissions
    • Plugin
    • PluginArray
    • PopStateEvent
    • Presentation
    • PresentationAvailability
    • PresentationConnection
    • PresentationConnectionAvailableEvent
    • PresentationConnectionCloseEvent
    • PresentationRequest
    • ProcessingInstruction
    • ProgressEvent
    • Promise
    • PromiseRejectionEvent
    • Proxy
    • PushManager
    • PushSubscription
    • RTCCertificate
    • RTCIceCandidate
    • RTCSessionDescription
    • RadioNodeList
    • Range
    • RangeError
    • ReadableByteStream
    • ReadableStream
    • ReferenceError
    • Reflect
    • RegExp
    • Request
    • Response
    • SVGAElement
    • SVGAngle
    • SVGAnimateElement
    • SVGAnimateMotionElement
    • SVGAnimateTransformElement
    • SVGAnimatedAngle
    • SVGAnimatedBoolean
    • SVGAnimatedEnumeration
    • SVGAnimatedInteger
    • SVGAnimatedLength
    • SVGAnimatedLengthList
    • SVGAnimatedNumber
    • SVGAnimatedNumberList
    • SVGAnimatedPreserveAspectRatio
    • SVGAnimatedRect
    • SVGAnimatedString
    • SVGAnimatedTransformList
    • SVGAnimationElement
    • SVGCircleElement
    • SVGClipPathElement
    • SVGComponentTransferFunctionElement
    • SVGCursorElement
    • SVGDefsElement
    • SVGDescElement
    • SVGDiscardElement
    • SVGElement
    • SVGEllipseElement
    • SVGFEBlendElement
    • SVGFEColorMatrixElement
    • SVGFEComponentTransferElement
    • SVGFECompositeElement
    • SVGFEConvolveMatrixElement
    • SVGFEDiffuseLightingElement
    • SVGFEDisplacementMapElement
    • SVGFEDistantLightElement
    • SVGFEDropShadowElement
    • SVGFEFloodElement
    • SVGFEFuncAElement
    • SVGFEFuncBElement
    • SVGFEFuncGElement
    • SVGFEFuncRElement
    • SVGFEGaussianBlurElement
    • SVGFEImageElement
    • SVGFEMergeElement
    • SVGFEMergeNodeElement
    • SVGFEMorphologyElement
    • SVGFEOffsetElement
    • SVGFEPointLightElement
    • SVGFESpecularLightingElement
    • SVGFESpotLightElement
    • SVGFETileElement
    • SVGFETurbulenceElement
    • SVGFilterElement
    • SVGForeignObjectElement
    • SVGGElement
    • SVGGeometryElement
    • SVGGradientElement
    • SVGGraphicsElement
    • SVGImageElement
    • SVGLength
    • SVGLengthList
    • SVGLineElement
    • SVGLinearGradientElement
    • SVGMPathElement
    • SVGMarkerElement
    • SVGMaskElement
    • SVGMatrix
    • SVGMetadataElement
    • SVGNumber
    • SVGNumberList
    • SVGPathElement
    • SVGPatternElement
    • SVGPoint
    • SVGPointList
    • SVGPolygonElement
    • SVGPolylineElement
    • SVGPreserveAspectRatio
    • SVGRadialGradientElement
    • SVGRect
    • SVGRectElement
    • SVGSVGElement
    • SVGScriptElement
    • SVGSetElement
    • SVGStopElement
    • SVGStringList
    • SVGStyleElement
    • SVGSwitchElement
    • SVGSymbolElement
    • SVGTSpanElement
    • SVGTextContentElement
    • SVGTextElement
    • SVGTextPathElement
    • SVGTextPositioningElement
    • SVGTitleElement
    • SVGTransform
    • SVGTransformList
    • SVGUnitTypes
    • SVGUseElement
    • SVGViewElement
    • SVGViewSpec
    • SVGZoomEvent
    • Screen
    • ScreenOrientation
    • ScriptProcessorNode
    • SecurityPolicyViolationEvent
    • Selection
    • ServiceWorker
    • ServiceWorkerContainer
    • ServiceWorkerMessageEvent
    • ServiceWorkerRegistration
    • Set
    • ShadowRoot
    • SharedWorker
    • SourceBuffer
    • SourceBufferList
    • SpeechSynthesisEvent
    • SpeechSynthesisUtterance
    • Storage
    • StorageEvent
    • String
    • StyleSheet
    • StyleSheetList
    • SubtleCrypto
    • Symbol
    • SyncManager
    • SyntaxError
    • Text
    • TextDecoder
    • TextEncoder
    • TextEvent
    • TextMetrics
    • TextTrack
    • TextTrackCue
    • TextTrackCueList
    • TextTrackList
    • TimeRanges
    • Touch
    • TouchEvent
    • TouchList
    • TrackEvent
    • TransitionEvent
    • TreeWalker
    • TypeError
    • UIEvent
    • URIError
    • URL
    • URLSearchParams
    • Uint16Array
    • Uint32Array
    • Uint8Array
    • Uint8ClampedArray
    • VTTCue
    • ValidityState
    • WaveShaperNode
    • WeakMap
    • WeakSet
    • WebGLActiveInfo
    • WebGLBuffer
    • WebGLContextEvent
    • WebGLFramebuffer
    • WebGLProgram
    • WebGLRenderbuffer
    • WebGLRenderingContext
    • WebGLShader
    • WebGLShaderPrecisionFormat
    • WebGLTexture
    • WebGLUniformLocation
    • WebKitAnimationEvent
    • WebKitCSSMatrix
    • WebKitMutationObserver
    • WebKitTransitionEvent
    • WebSocket
    • WheelEvent
    • Window
    • Worker
    • XMLDocument
    • XMLHttpRequest
    • XMLHttpRequestEventTarget
    • XMLHttpRequestUpload
    • XMLSerializer
    • XPathEvaluator
    • XPathExpression
    • XPathResult
    • XSLTProcessor
    • alert
    • applicationCache
    • atob
    • backspaceDelete
    • blur
    • btoa
    • caches
    • cancelAnimationFrame
    • cancelIdleCallback
    • captureEvents
    • chrome
    • clearInterval
    • clearTimeout
    • clientInformation
    • clipboard
    • close
    • closed
    • confirm
    • console
    • createImageBitmap
    • crypto
    • decodeURI
    • decodeURIComponent
    • defaultStatus
    • defaultstatus
    • devicePixelRatio
    • document
    • encodeURI
    • encodeURIComponent
    • escape
    • eval
    • event
    • external
    • fetch
    • find
    • focus
    • frameElement
    • frames
    • getComputedStyle
    • getMatchedCSSRules
    • getSelection
    • history
    • indexedDB
    • innerHeight
    • innerText
    • innerWidth
    • isFinite
    • isNaN
    • isSecureContext
    • length
    • localStorage
    • location
    • locationbar
    • matchMedia
    • menubar
    • moveBy
    • moveTo
    • name
    • navigator
    • offscreenBuffering
    • onabort
    • onanimationend
    • onanimationiteration
    • onanimationstart
    • onautocomplete
    • onautocompleteerror
    • onbeforeunload
    • onblur
    • oncancel
    • oncanplay
    • oncanplaythrough
    • onchange
    • onclick
    • onclose
    • oncontextmenu
    • oncuechange
    • ondblclick
    • ondevicemotion
    • ondeviceorientation
    • ondeviceorientationabsolute
    • ondrag
    • ondragend
    • ondragenter
    • ondragleave
    • ondragover
    • ondragstart
    • ondrop
    • ondurationchange
    • onemptied
    • onended
    • onerror
    • onfocus
    • onhashchange
    • oninput
    • oninvalid
    • onkeydown
    • onkeypress
    • onkeyup
    • onlanguagechange
    • onload
    • onloadeddata
    • onloadedmetadata
    • onloadstart
    • onmessage
    • onmousedown
    • onmouseenter
    • onmouseleave
    • onmousemove
    • onmouseout
    • onmouseover
    • onmouseup
    • onmousewheel
    • onoffline
    • ononline
    • onpagehide
    • onpageshow
    • onpause
    • onplay
    • onplaying
    • onpopstate
    • onprogress
    • onratechange
    • onrejectionhandled
    • onreset
    • onresize
    • onscroll
    • onsearch
    • onseeked
    • onseeking
    • onselect
    • onshow
    • onstalled
    • onstorage
    • onsubmit
    • onsuspend
    • ontimeupdate
    • ontoggle
    • ontransitionend
    • onunhandledrejection
    • onunload
    • onvolumechange
    • onwaiting
    • onwebkitanimationend
    • onwebkitanimationiteration
    • onwebkitanimationstart
    • onwebkittransitionend
    • onwheel
    • open
    • openDatabase
    • opener
    • outerHeight
    • outerWidth
    • pageXOffset
    • pageYOffset
    • parent
    • parseFloat
    • parseInt
    • performance
    • personalbar
    • postMessage
    • print
    • prompt
    • releaseEvents
    • requestAnimationFrame
    • requestIdleCallback
    • resizeBy
    • resizeTo
    • screen
    • screenLeft
    • screenTop
    • screenX
    • screenY
    • scroll
    • scrollBy
    • scrollTo
    • scrollX
    • scrollY
    • scrollbars
    • self
    • sessionStorage
    • setInterval
    • setTimeout
    • speechSynthesis
    • status
    • statusbar
    • stop
    • styleMedia
    • toolbar
    • top
    • undefined
    • unescape
    • webkitAudioContext
    • webkitCancelAnimationFrame
    • webkitCancelRequestAnimationFrame
    • webkitIDBCursor
    • webkitIDBDatabase
    • webkitIDBFactory
    • webkitIDBIndex
    • webkitIDBKeyRange
    • webkitIDBObjectStore
    • webkitIDBRequest
    • webkitIDBTransaction
    • webkitIndexedDB
    • webkitMediaStream
    • webkitOfflineAudioContext
    • webkitRTCPeerConnection
    • webkitRequestAnimationFrame
    • webkitRequestFileSystem
    • webkitResolveLocalFileSystemURL
    • webkitSpeechGrammar
    • webkitSpeechGrammarList
    • webkitSpeechRecognition
    • webkitSpeechRecognitionError
    • webkitSpeechRecognitionEvent
    • webkitStorageInfo
    • webkitURL
    • window
    • wordFilter

ljbapiNtv'GENERIC-SPECIFIC-TREE

Description:
This is the inheritance tree (= specifics inherit the-members of generics) of the-objects of the-language.
The-Object.prototype is the-most-generic-object in the-API's-generic-specific-tree.

Name:
* cpt.ljb'API's-generic-specific-tree,
* cpt.ljbAPI's-generic-specific-tree,
* cpt.ljb'object-generic-specific-tree,
* cpt.ljbobject-generic-specific-tree,
* cpt.ljb'object-hierarchy,
* cpt.ljbobject-hierarchy,
* cpt.ljb'gst,
* cpt.ljbgst,

Generic-Specific-Tree of ljb-native-API:

  • Object.prototype (ROOT)
    • Array.prototype,
    • Boolean.prototype,
    • EventTarget.prototype,
      • Node.prototype,
        • Attr.prototype,
        • CharacterData.prototype,
          • Comment.prototype,
          • Text.prototype,
        • Document.prototype,
        • DocumentFragment.prototype,
        • DocumentType.prototype,
        • Element.prototype,
          • HTMLElement.prototype,
            • HTMLAnchorElement.prototype,
            • HTMLAreaElement.prototype,
            • HTMLAudioElement.prototype,
            • HTMLBRElement.prototype,
            • HTMLBaseElement.prototype,
            • HTMLBodyElement.prototype,
            • HTMLButtonElement.prototype,
            • HTMLCanvasElement.prototype,
            • HTMLContentElement.prototype,
            • HTMLDListElement.prototype,
            • HTMLDataListElement.prototype,
            • HTMLDetailsElement.prototype,
            • HTMLDialogElement.prototype,
            • HTMLDirectoryElement.prototype,
            • HTMLDivElement.prototype,
            • HTMLEmbedElement.prototype,
            • HTMLFieldSetElement.prototype,
            • HTMLFontElement.prototype,
            • HTMLFormElement.prototype,
            • HTMLFrameElement.prototype,
            • HTMLFrameSetElement.prototype,
            • HTMLHRElement.prototype,
            • HTMLHeadElement.prototype,
            • HTMLHeadingElement.prototype,
            • HTMLHtmlElement.prototype,
            • HTMLIFrameElement.prototype,
            • HTMLImageElement.prototype,
            • HTMLInputElement.prototype,
            • HTMLKeygenElement.prototype,
            • HTMLLIElement.prototype,
            • HTMLLabelElement.prototype,
            • HTMLLegendElement.prototype,
            • HTMLLinkElement.prototype,
            • HTMLMapElement.prototype,
            • HTMLMarqueeElement.prototype,
            • HTMLMediaElement.prototype,
            • HTMLMenuElement.prototype,
            • HTMLMetaElement.prototype,
            • HTMLMeterElement.prototype,
            • HTMLModElement.prototype,
            • HTMLOListElement.prototype,
            • HTMLObjectElement.prototype,
            • HTMLOptGroupElement.prototype,
            • HTMLOptionElement.prototype,
            • HTMLOptionsCollection.prototype,
            • HTMLOutputElement.prototype,
            • HTMLParagraphElement.prototype,
            • HTMLParamElement.prototype,
            • HTMLPictureElement.prototype,
            • HTMLPreElement.prototype,
            • HTMLProgressElement.prototype,
            • HTMLQuoteElement.prototype,
            • HTMLScriptElement.prototype,
            • HTMLSelectElement.prototype,
            • HTMLShadowElement.prototype,
            • HTMLSourceElement.prototype,
            • HTMLSpanElement.prototype,
            • HTMLStyleElement.prototype,
            • HTMLTableCaptionElement.prototype,
            • HTMLTableCellElement.prototype,
            • HTMLTableColElement.prototype,
            • HTMLTableElement.prototype,
            • HTMLTableRowElement.prototype,
            • HTMLTableSectionElement.prototype,
            • HTMLTemplateElement.prototype,
            • HTMLTextAreaElement.prototype,
            • HTMLTitleElement.prototype,
            • HTMLTrackElement.prototype,
            • HTMLUListElement.prototype,
            • HTMLUnknownElement.prototype,
            • HTMLVideoElement.prototype,
      • (WindowProperties.prototype),
        • Window.prototype,
    • Date.prototype,
    • Error.prototype,
    • Event.prototype,
    • Function.prototype,
    • Math, (Math.__proto__ === Object.prototype //true)
    • Location.prototype,
    • Navigator.prototype,
    • NodeFilter.prototype,
    • NodeIterator.prototype,
    • Number.prototype,
    • Range.prototype,
    • RegExp.prototype,
    • String.prototype,
    • TreeWalker.prototype,
    • ....

ljbapiNtv'window

Description:
window is an-objectof Window function.
It is the-most-whole object of the-browsers, the-global-object, it includes all other language constructs.
It is the-ROOT of the-API-whole-part-tree.

Name:
* cpt.ljb'window,
* cpt.ljbwindow,
* cpt.ljb'global-object,
* cpt.ljbglobal-object,
* cpt.ljb'most-whole-object,
* cpt.ljbmost-whole-object,

Whole-chain:
* none,

Generic-chain:
* Window.prototype (Window.prototype.isPrototypeOf(window) // true),
* WindowProperties.prototype (internal in Chrome)
* EventTarget.prototype (Window.prototype.__proto__.__proto__ === EventTarget.prototype // true),
* Object.prototype,

ljbalgo'PHRASE

Generic:
* ljs-phrase,

Name:
* cpt.ljb'phrase,
* cpt.ljbphrase,
* cpt.ljb'semantic-unit-structure,
* cpt.ljbsemantic-unit-structure,
* cpt.ljb'sus,
* cpt.ljbsus,

ljbalgo'SENTENCE

Generic:
* ljs-sentence,

Name:
* cpt.ljb'sentence,
* cpt.ljbsentence,
* cpt.ljb'statement,
* cpt.ljbstatement,

ljbalgo'ROOT-TREE

Description:
Algo-root-tree is the OUTERMOST TREE of an-algorithm, in a-webpage.

Name:
* cpt.ljb'algo-root-tree,
* cpt.ljbalgo-root-tree,
* cpt.ljb-algo-root,

Part:
* the-root-node,
* the-children of the-root-node,

ljbalgo.SPECIFIC

Description:
With the-language programers create many algorithms.
The-quantity depends on the-archetypes known, and the-semantic-units of the-language.

Specific:
* Browser-management,
* Event-management,
* HML-management,
* Math-management,
* Time-management,

ljbalgo.LIBRARY

Generic:
* ljs-library,

Name:
* cpt.ljb'library,
* cpt.ljb'framework,
* cpt.ljb'plugin,
* cpt.ljb'script,
* cpt.ljblibrary,
* cpt.ljb'lbr,
* cpt.ljblbr,
* ljblibrary-cpt,

ljblbr'adding

Description:
To add a-library in your code, to use its semantic-units (its API):
1. Use the-script HML-element to add the-javascript file|s:
<script src="location-of-file/file.js"></script>
Then all the-semantic-units of the-library were-added in the-ljb-most-whole-object (global).
Because the-library's-API is-added in the-global-object (window), it is a good practice, to store the-custom-semantic-units of the-library as part of ONE semantic-unit (usually object).
2. Use the-link HML-element to add the-CSS file|s, if present:
<link rel="stylesheet" href="location-of-file/file.css" />

ljblbr.SPECIFIC

Specific:
* http://www.javascripting.com/

ljblbr.TEMPLATING

Description:
JavaScript templating refers to the client side data binding method implemented with the JavaScript language.
This approach became popular thanks to JavaScript's increased use, its increase in client processing capabilities, and the trend to outsource computations to the client's web browser. Popular JavaScript templating libraries are AngularJS, Backbone.js, Ember.js, Handlebars.js, Vue.js and Mustache.js.
A frequent practice is to use double curly brackets (i.e. {{key}}) to call values of the given key from data files, often JSON objects.

[https://en.wikipedia.org/wiki/JavaScript_templating]

Name:
* cpt.ljb'templating-library,
* cpt.javascript-templating-library,
* javascript-templating-library-cpt,

Specific:
* AngularJS,
* Backbone.js,
* Chaplin.js,
* Dust.js,
* Ember.js,
* Handlebars.js,
* HTMLBars,
* KnockoutJS,
* Marko.js,
* Mustache.js,
* React.js,
* Underscore.js,
* Vue.js,

ljbalgo.PROGRAM

Description:
Ljb-program is an-algorithm which can-run autonomously, written in code-format, in a-webpage.

Name:
* cpt.ljb'algo-program,
* cpt.ljbalgo-program,
* cpt.ljb-algo-program,
* cpt.ljb'program,
* cpt.ljbprogram,

Part:
* ljb-library,
* ljb-sentence,

ljbpgm'Execution

Description:
You open the-HML-doc (webpage) in a-webbrowser which contains it.

Name:
* cpt.ljb'program'execution,
* cpt.ljbprogram'execution,
* cpt.ljbpgm'call,
* cpt.ljbpgm'execution,
* cpt.ljbpgm'invocation,
* cpt.ljbpgm'open,
* cpt.ljbpgm'run,

ljbalgo.Hello-World!

Description:
This is the classic simplest program that displays the-text 'Hello World'.
You can-open it from this link.


    Code:
      <!DOCTYPE html>
      <html>
        <head>
          <title>ljbpgm.Hello_World</title>
        </head>
        <body>
          <script>
            alert('Hello World!');
          </script>
        </body>
      </html>
    

Name:
* cpt.ljb'program.Hello-World!,
* cpt.ljbprogram.Hello-World!,
* cpt.ljbpgm.Hello-World!,

ljbalgo.BROWSER-PROCESSING (ljbalgBsr)

Description:
Browser-management is the-algorithm dealing with the-browser, which is the host environment for ljb.

Name:
* cpt.ljb'browser-management,
* cpt.ljbbrowser-management,
* cpt.ljb'browser-manipulation,
* cpt.ljb'browser-manipulation,
* cpt.ljbbrowser-processing,
* cpt.ljb'algBsr,
* cpt.ljbalgBsr,

ljbalgBsr'API

Whole-part-tree:

  • window,
    • History,
      • History.prototype,
    • history,
    • Location,
      • Location.prototype,
    • location,
    • Navigator,
      • Navigator.prototype,
    • navigator,
    • Screen,
      • Screen.prototype,
    • screen,
    • Window,
      • Window.prototype,
    • window,

ljbalgBsr'Window-function

Description:
Window is the-constructor of window (window.constructor //function Window() { [native code] }).

Name:
* cpt.ljb'Window,
* cpt.ljbWindow,
* cpt.ljb'Window-function,
* cpt.ljbWindow-function,

Whole-chain:
* window,

Generic-chain:
* EventTarget,
* Function.prototype,
* Object.prototype,

Member:
(Chrome.50):
> Object.getOwnPropertyNames(Window).sort()
["PERSISTENT", "TEMPORARY", "arguments", "caller", "length", "name", "prototype"]

(Firefox.46):
> Object.getOwnPropertyNames(Window).sort()
["length", "name", "prototype"]

(Edge.20):
> Object.getOwnPropertyNames(Window).sort()
[ "arguments", "caller", "name", "prototype" ]

ljbalgo.EVENT-PROCESSING (ljbalgEvt)

Description:
Events (webpage-events) are DOINGS in a-webpage, such as mouse clicks, mouse overs, etc.
Events AND associated functions (the-event-listeners) ARE-REGISTERED on components of the-page (the-targets).
When events occur, their associated event-listeners ARE-TRIGGERED (are-called).
oTarget.addEventListener(sEvent, fEventlistener);

Name:
* cpt.ljb'event-management,
* cpt.ljbevent-management,
* cpt.ljb'event-manipulation,
* cpt.ljb'algEvt,
* cpt.ljbalgEvt,

ljbalgEvt'API

Whole-part-tree:

  • window, (ROOT)
    • ApplicationCacheErrorEvent,
      • ApplicationCacheErrorEvent.prototype,
    • AudioProcessingEvent,
      • AudioProcessingEvent.prototype,
    • AutocompleteErrorEvent,
      • AutocompleteErrorEvent.prototype,
    • BeforeUnloadEvent,
      • BeforeUnloadEvent.prototype,
    • CloseEvent,
      • CloseEvent.prototype,
    • CompositionEvent,
      • CompositionEvent.prototype,
    • CustomEvent,
      • CustomEvent.prototype,
    • DeviceMotionEvent,
      • DeviceMotionEvent.prototype,
    • DeviceOrientationEvent,
      • DeviceOrientationEvent.prototype,
    • DragEvent,
      • DragEvent.prototype,
    • ErrorEvent,
      • ErrorEvent.prototype,
    • Event,
    • EventTarget,
    • FocusEvent,
      • FocusEvent.prototype,
    • GamepadEvent,
      • GamepadEvent.prototype,
    • HashChangeEvent,
      • HashChangeEvent.prototype,
    • IDBVersionChangeEvent,
      • IDBVersionChangeEvent.prototype,
    • KeyboardEvent,
      • KeyboardEvent.prototype,
    • MediaKeyMessageEvent,
      • MediaKeyMessageEvent.prototype,
    • MediaStreamEvent,
      • MediaStreamEvent.prototype,
    • MessageEvent,
      • MessageEvent.prototype,
    • MouseEvent,
      • MouseEvent.prototype,
    • MutationEvent,
      • MutationEvent.prototype,
    • OfflineAudioCompletionEvent,
      • OfflineAudioCompletionEvent.prototype,
    • PageTransitionEvent,
      • PageTransitionEvent.prototype,
    • PopStateEvent,
      • PopStateEvent.prototype,
    • ProgressEvent,
      • ProgressEvent.prototype,
    • SpeechSynthesisEvent,
      • SpeechSynthesisEvent.prototype,
    • StorageEvent,
      • StorageEvent.prototype,
    • SVGZoomEvent,
      • SVGZoomEvent.prototype,
    • TextEvent,
      • TextEvent.prototype,
    • TouchEvent,
      • TouchEvent.prototype,
    • TrackEvent,
      • TrackEvent.prototype,
    • TransitionEvent,
      • TransitionEvent.prototype,
    • UIEvent,
      • UIEvent.prototype,
    • WebGLContextEvent,
      • WebGLContextEvent.prototype,
    • WebKitAnimationEvent,
      • WebKitAnimationEvent.prototype,
    • webkitSpeechRecognitionEvent.prototype,
    • WebKitTransitionEvent,
      • WebKitTransitionEvent.prototype,
    • WheelEvent,
      • WheelEvent.prototype,

Generic-specific-tree:

  • Object.prototype, (ROOT)
    • Event.prototype,
      • ApplicationCacheErrorEvent.prototype,
        • oApplicationCacheErrorEvent,
      • AudioProcessingEvent.prototype,
        • oAudioProcessingEvent,
      • AutocompleteErrorEvent.prototype,
        • oAutocompleteErrorEvent,
      • BeforeUnloadEvent.prototype,
        • oBeforeUnloadEvent,
      • CloseEvent.prototype,
        • oCloseEvent,
      • CustomEvent.prototype,
        • oCustomEvent,
      • DeviceMotionEvent.prototype,
        • oDeviceMotionEvent,
      • DeviceOrientationEvent.prototype,
        • oDeviceOrientationEvent,
      • ErrorEvent.prototype,
        • oErrorEvent,
      • GamepadEvent.prototype,
        • oGamepadEvent,
      • HashChangeEvent.prototype,
        • oHashChangeEvent,
      • IDBVersionChangeEvent.prototype,
        • oIDBVersionChangeEvent,
      • MediaKeyMessageEvent.prototype,
        • oMediaKeyMessageEvent,
      • MediaStreamEvent.prototype,
        • oMediaStreamEvent,
      • MessageEvent.prototype,
        • oMessageEvent,
      • MutationEvent.prototype,
        • oMutationEvent,
      • OfflineAudioCompletionEvent.prototype,
        • oOfflineAudioCompletionEvent,
      • PageTransitionEvent.prototype,
        • oPageTransitionEvent,
      • PopStateEvent.prototype,
        • oPopStateEvent,
      • ProgressEvent.prototype,
        • oProgressEvent,
      • SpeechSynthesisEvent.prototype,
        • oSpeechSynthesisEvent,
      • StorageEvent.prototype,
        • oStorageEvent,
      • TrackEvent.prototype,
        • oTrackEvent,
      • TransitionEvent.prototype,
        • oTransitionEvent,
      • UIEvent.prototype,
        • oUIEvent,
        • CompositionEvent.prototype,
          • oCompositionEvent,
        • FocusEvent.prototype,
          • oFocusEvent,
        • KeyboardEvent.prototype,
          • oKeyboardEvent,
        • MouseEvent.prototype,
          • oMouseEvent,
          • DragEvent.prototype,
            • oDragEvent,
          • WheelEvent.prototype,
            • oWheelEvent,
        • SVGZoomEvent.prototype,
          • oSVGZoomEvent,
        • TextEvent.prototype,
          • oTextEvent,
        • TouchEvent.prototype,
          • oTouchEvent,
      • WebGLContextEvent.prototype,
        • oWebGLContextEvent,
      • WebKitAnimationEvent.prototype,
        • oWebKitAnimationEvent,
      • WebKitTransitionEvent.prototype,
        • oWebKitTransitionEvent,
      • webkitSpeechRecognitionEvent.prototype,
    • EventTarget.prototype,

ljbalgEvt'Event-object (oEvt)

Description:
Ljb-event-object is an-object that represents webpage-events (its archetype).
Ljb has many constructors that create event-objects.
All event-objects inherit from Event.prototype.

Name:
* cpt.ljb'event-object,
* cpt.ljbevent-object,
* cpt.ljb'evtobt,
* cpt.ljbevtobt,
* cpt.ljboEvt,

Whole-chain:
* the-semantic-unit in which defined.

Generic-chain:
* Constructor.prototype,
* Event.prototype,
* Object.prototype,

Member:
The-members of an-oEvt depend of the-constructor used to create them.

Constructor:
These constructors create oEvts.
* ApplicationCacheErrorEvent,
* AudioProcessingEvent,
* AutocompleteErrorEvent,
* BeforeUnloadEvent,
* CloseEvent,
* CompositionEvent,
* CustomEvent,
* DeviceMotionEvent,
* DeviceOrientationEvent,
* DragEvent,
* ErrorEvent,
* Event,
* FocusEvent,
* GamepadEvent,
* HashChangeEvent,
* IDBVersionChangeEvent,
* KeyboardEvent,
* MediaKeyMessageEvent,
* MediaStreamEvent,
* MessageEvent,
* MouseEvent,
* MutationEvent,
* OfflineAudioCompletionEvent,
* PageTransitionEvent,
* PopStateEvent,
* ProgressEvent,
* SpeechSynthesisEvent,
* StorageEvent,
* SVGZoomEvent,
* TextEvent,
* TouchEvent,
* TrackEvent,
* TransitionEvent,
* UIEvent,
* WebGLContextEvent,
* WebKitAnimationEvent,
* WebKitTransitionEvent,
* WheelEvent,

ljbalgEvt'Event-listener-function (fEvtlnr)

Description:
Ljb-event-listener-function is a-function that is-called when the-event occurs on a-target.

Name:
* cpt.ljb'event-listener-function,
* cpt.ljbevent-listener-function,
* cpt.ljb'event-listener,
* cpt.ljbevent-listener,
* cpt.ljb'fEvtlnr,
* cpt.ljbfEvtlnr,

Whole-chain:
* the-semantic-unit in which defined.

Generic-chain:
* Function.prototype,
* Object.prototype,

ljbalgEvt'Event-target-object (oEvttgt)

Description:
Ljb-event-target-object is an-object that represents an-HML-element of the-webpage on which the-event is-registered.

Name:
* cpt.ljb'event-target-object,
* cpt.ljbevent-target-object,
* cpt.ljb'event-target,
* cpt.ljbevent-target,
* cpt.ljb'oEvttgt,
* cpt.ljboEvttgt,

Whole-chain:
* the-semantic-unit in which defined.

Generic-chain:
* ...
* Node.prototype,
* EventTarget.prototype,
* Object.prototype,
===
All targets are specific of EventTarget.prototype which contains the-method addEventListener() we need to add listeners on targets.

ljbalgEvt'Event.prototype

Description:
Event.prototype is the-generic-object of all ljb-event-objects which represent webpage-events.

Name:
* cpt.ljb'Event.prototype,
* cpt.ljbEvent.prototype,

Whole-chain:
* Event-function,
* window, (window.Event //function Event() { [native code] })

Generic-chain:
* Object.prototype, (Event.prototype.__proto__ === Object.prototype //true)

Member:
(Chrome.50):
> Object.getOwnPropertyNames(Event.prototype).sort()
["AT_TARGET", "BLUR", "BUBBLING_PHASE", "CAPTURING_PHASE", "CHANGE", "CLICK", "DBLCLICK", "DRAGDROP", "FOCUS", "KEYDOWN", "KEYPRESS", "KEYUP", "MOUSEDOWN", "MOUSEDRAG", "MOUSEMOVE", "MOUSEOUT", "MOUSEOVER", "MOUSEUP", "NONE", "SELECT", "bubbles", "cancelBubble", "cancelable", "constructor", "currentTarget", "defaultPrevented", "eventPhase", "initEvent", "path", "preventDefault", "returnValue", "srcElement", "stopImmediatePropagation", "stopPropagation", "target", "timeStamp", "type"]

(Firefox.46):
> Object.getOwnPropertyNames(Event.prototype).sort()
[]

(Edge.20):
> Object.getOwnPropertyNames(Event.prototype).sort()
[]

(Safari.5.1.7):
> Object.getOwnPropertyNames(Event.prototype).sort()
[]

ljbalgEvt'Event-function

Description:
Event is a -constructor of ljb-event-objects which contains the-Event.prototype, the-generic of all oEvts.

Name:
* cpt.ljb'Event,
* cpt.ljbEvent,
* cpt.ljb'Event-constructor,
* cpt.ljbEvent-constructor,
* cpt.ljb'Event-function,
* cpt.ljbEvent-function,

Whole-chain:
* window, (window.Event //function Event() { [native code] })

Generic-chain:
* Function.prototype, (Event.__proto__ === Function.prototype //true)
* Object.prototype, (Event.__proto__.__proto__ === Object.prototype //true)

Member:
(Chrome.50):
> Object.getOwnPropertyNames(Event).sort()
["AT_TARGET", "BLUR", "BUBBLING_PHASE", "CAPTURING_PHASE", "CHANGE", "CLICK", "DBLCLICK", "DRAGDROP", "FOCUS", "KEYDOWN", "KEYPRESS", "KEYUP", "MOUSEDOWN", "MOUSEDRAG", "MOUSEMOVE", "MOUSEOUT", "MOUSEOVER", "MOUSEUP", "NONE", "SELECT", "arguments", "caller", "length", "name", "prototype"]

(Firefox.46):
> Object.getOwnPropertyNames(Event).sort()
["ALT_MASK", "AT_TARGET", "BUBBLING_PHASE", "CAPTURING_PHASE", "CONTROL_MASK", "META_MASK", "NONE", "SHIFT_MASK", "length", "name", "prototype"]

(Edge.20):
> Object.getOwnPropertyNames(Event).sort()
[]

(Safari.5.1.7):
> Object.getOwnPropertyNames(Event).sort()
[]

ljbalgEvt'EventTarget.prototype

Description:
EventTarget.prototype is the-generic-object of Node.prototype, and thus of any component of a-webpage.

Name:
* cpt.ljb'EventTarget.prototype,
* cpt.ljbEventTarget.prototype,

Whole-chain:
* EventTarget-function,
* window, (window.EventTarget //function EventTarget() { [native code] })

Generic-chain:
* Object.prototype, (EventTarget.prototype.__proto__ === Object.prototype //true)

Member:
(Chrome.50):
> Object.getOwnPropertyNames(EventTarget.prototype).sort()
["addEventListener", "constructor", "dispatchEvent", "removeEventListener"]

(Firefox.46):
> Object.getOwnPropertyNames(EventTarget.prototype).sort()
["addEventListener", "constructor", "dispatchEvent", "removeEventListener"]

(Edge.20):
> Object.getOwnPropertyNames(EventTarget.prototype).sort()
["addEventListener", "constructor", "dispatchEvent", "removeEventListener"]

(Safari.5.1.7):
> Object.getOwnPropertyNames(EventTarget.prototype).sort()
[]

ljbalgEvt'EventTarget-function

Description:
EventTarget is the-constructor of the-EventTarget.prototype.

Name:
* cpt.ljb'EventTarget,
* cpt.ljbEventTarget,
* cpt.ljb'EventTarget-constructor,
* cpt.ljbEventTarget-constructor,
* cpt.ljb'EventTarget-function,
* cpt.ljbEventTarget-function,

Whole-chain:
* window, (window.EventTarget //function EventTarget() { [native code] })

Generic-chain:
* Function.prototype, (EventTarget.__proto__ === Function.prototype //true)
* Object.prototype, (EventTarget.__proto__.__proto__ === Object.prototype //true)

Member:
(Chrome.50):
> Object.getOwnPropertyNames(EventTarget).sort()
["arguments", "caller", "length", "name", "prototype"]

(Firefox.46):
> Object.getOwnPropertyNames(EventTarget).sort()
["length", "name", "prototype"]

(Edge.20):
> Object.getOwnPropertyNames(EventTarget).sort()
["arguments", "caller", "name", "prototype"]

Specific:
* Window, (Window.__proto__ === EventTarget //true)

ljbalgo.HML-PROCESSING (ljbalgHml)

Description:
ALL ljb-algorithms manage HML, because ljb-code is part of an-HML-document and this reason of existance of ljb.

Name:
* cpt.ljb'HML-management,
* cpt.ljbHML-management,
* cpt.ljb'algHml,
* cpt.ljbalgHml,

ljbalgHml'API

Name:
* cpt.ljb'HML-API,
* cpt.ljb'hml-API,
* cpt.ljb'API.HML,

ljb'Hml-API'Whole-part-tree:

  • window, (ROOT)
    • Attr,
    • CharacterData,
    • Comment,
      • Comment.prototype,
    • EventTarget,
    • Document,
    • document,
    • DocumentFragment,
    • DocumentType,
    • Element,
    • HTMLDocument,
    • HTMLElement,
    • HTMLAnchorElement,
      • HTMLAnchorElement.prototype,
    • HTMLAreaElement,
      • HTMLAreaElement.prototype,
    • HTMLAudioElement,
      • HTMLAudioElement.prototype,
    • HTMLBRElement,
      • HTMLBRElement.prototype,
    • HTMLBaseElement,
      • HTMLBaseElement.prototype,
    • HTMLBodyElement,
      • HTMLBodyElement.prototype,
    • HTMLButtonElement,
      • HTMLButtonElement.prototype,
    • HTMLCanvasElement,
      • HTMLCanvasElement.prototype,
    • HTMLContentElement,
      • HTMLContentElement.prototype,
    • HTMLDListElement,
      • HTMLDListElement.prototype,
    • HTMLDataListElement,
      • HTMLDataListElement.prototype,
    • HTMLDetailsElement,
      • HTMLDetailsElement.prototype,
    • HTMLDialogElement,
      • HTMLDialogElement.prototype,
    • HTMLDirectoryElement,
      • HTMLDirectoryElement.prototype,
    • HTMLDivElement,
      • HTMLDivElement.prototype,
    • HTMLEmbedElement,
      • HTMLEmbedElement.prototype,
    • HTMLFieldSetElement,
      • HTMLFieldSetElement.prototype,
    • HTMLFontElement,
      • HTMLFontElement.prototype,
    • HTMLFormElement,
      • HTMLFormElement.prototype,
    • HTMLFrameElement,
      • HTMLFrameElement.prototype,
    • HTMLFrameSetElement,
      • HTMLFrameSetElement.prototype,
    • HTMLHRElement,
      • HTMLHRElement.prototype,
    • HTMLHeadElement,
      • HTMLHeadElement.prototype,
    • HTMLHeadingElement,
      • HTMLHeadingElement.prototype,
    • HTMLHtmlElement,
      • HTMLHtmlElement.prototype,
    • HTMLIFrameElement,
      • HTMLIFrameElement.prototype,
    • HTMLImageElement,
      • HTMLImageElement.prototype,
    • HTMLInputElement,
      • HTMLInputElement.prototype,
    • HTMLKeygenElement,
      • HTMLKeygenElement.prototype,
    • HTMLLIElement,
      • HTMLLIElement.prototype,
    • HTMLLabelElement,
      • HTMLLabelElement.prototype,
    • HTMLLegendElement,
      • HTMLLegendElement.prototype,
    • HTMLLinkElement,
      • HTMLLinkElement.prototype,
    • HTMLMapElement,
      • HTMLMapElement.prototype,
    • HTMLMarqueeElement,
      • HTMLMarqueeElement.prototype,
    • HTMLMediaElement,
      • HTMLMediaElement.prototype,
    • HTMLMenuElement,
      • HTMLMenuElement.prototype,
    • HTMLMetaElement,
      • HTMLMetaElement.prototype,
    • HTMLMeterElement,
      • HTMLMeterElement.prototype,
    • HTMLModElement,
      • HTMLModElement.prototype,
    • HTMLOListElement,
      • HTMLOListElement.prototype,
    • HTMLObjectElement,
      • HTMLObjectElement.prototype,
    • HTMLOptGroupElement,
      • HTMLOptGroupElement.prototype,
    • HTMLOptionElement,
      • HTMLOptionElement.prototype,
    • HTMLOptionsCollection,
      • HTMLOptionsCollection.prototype,
    • HTMLOutputElement,
      • HTMLOutputElement.prototype,
    • HTMLParagraphElement,
      • HTMLParagraphElement.prototype,
    • HTMLParamElement,
      • HTMLParamElement.prototype,
    • HTMLPictureElement,
      • HTMLPictureElement.prototype,
    • HTMLPreElement,
      • HTMLPreElement.prototype,
    • HTMLProgressElement,
      • HTMLProgressElement.prototype,
    • HTMLQuoteElement,
      • HTMLQuoteElement.prototype,
    • HTMLScriptElement,
      • HTMLScriptElement.prototype,
    • HTMLSelectElement,
      • HTMLSelectElement.prototype,
    • HTMLShadowElement,
      • HTMLShadowElement.prototype,
    • HTMLSourceElement,
      • HTMLSourceElement.prototype,
    • HTMLSpanElement,
      • HTMLSpanElement.prototype,
    • HTMLStyleElement,
      • HTMLStyleElement.prototype,
    • HTMLTableCaptionElement,
      • HTMLTableCaptionElement.prototype,
    • HTMLTableCellElement,
      • HTMLTableCellElement.prototype,
    • HTMLTableColElement,
      • HTMLTableColElement.prototype,
    • HTMLTableElement,
      • HTMLTableElement.prototype,
    • HTMLTableRowElement,
      • HTMLTableRowElement.prototype,
    • HTMLTableSectionElement,
      • HTMLTableSectionElement.prototype,
    • HTMLTemplateElement,
      • HTMLTemplateElement.prototype,
    • HTMLTextAreaElement,
      • HTMLTextAreaElement.prototype,
    • HTMLTitleElement,
      • HTMLTitleElement.prototype,
    • HTMLTrackElement,
      • HTMLTrackElement.prototype,
    • HTMLUListElement,
      • HTMLUListElement.prototype,
    • HTMLUnknownElement,
      • HTMLUnknownElement.prototype,
    • HTMLVideoElement,
      • HTMLVideoElement.prototype,
    • Node,
      • Node.prototype,
    • Text,
      • Text.prototype,

ljb'Hml-API'Generic-specific-tree:

  • Object.prototype, (ROOT)
    • EventTarget.prototype,
      • Node.prototype,
        • Attr.prototype,
        • CharacterData.prototype,
          • Comment.prototype,
          • Text.prototype,
        • Document.prototype,
        • DocumentFragment.prototype,
        • DocumentType.prototype,
        • Element.prototype,
          • HTMLElement.prototype,
            • HTMLAnchorElement.prototype,
            • HTMLAreaElement.prototype,
            • HTMLAudioElement.prototype,
            • HTMLBRElement.prototype,
            • HTMLBaseElement.prototype,
            • HTMLBodyElement.prototype,
            • HTMLButtonElement.prototype,
            • HTMLCanvasElement.prototype,
            • HTMLContentElement.prototype,
            • HTMLDListElement.prototype,
            • HTMLDataListElement.prototype,
            • HTMLDetailsElement.prototype,
            • HTMLDialogElement.prototype,
            • HTMLDirectoryElement.prototype,
            • HTMLDivElement.prototype,
            • HTMLEmbedElement.prototype,
            • HTMLFieldSetElement.prototype,
            • HTMLFontElement.prototype,
            • HTMLFormElement.prototype,
            • HTMLFrameElement.prototype,
            • HTMLFrameSetElement.prototype,
            • HTMLHRElement.prototype,
            • HTMLHeadElement.prototype,
            • HTMLHeadingElement.prototype,
            • HTMLHtmlElement.prototype,
            • HTMLIFrameElement.prototype,
            • HTMLImageElement.prototype,
            • HTMLInputElement.prototype,
            • HTMLKeygenElement.prototype,
            • HTMLLIElement.prototype,
            • HTMLLabelElement.prototype,
            • HTMLLegendElement.prototype,
            • HTMLLinkElement.prototype,
            • HTMLMapElement.prototype,
            • HTMLMarqueeElement.prototype,
            • HTMLMediaElement.prototype,
            • HTMLMenuElement.prototype,
            • HTMLMetaElement.prototype,
            • HTMLMeterElement.prototype,
            • HTMLModElement.prototype,
            • HTMLOListElement.prototype,
            • HTMLObjectElement.prototype,
            • HTMLOptGroupElement.prototype,
            • HTMLOptionElement.prototype,
            • HTMLOptionsCollection.prototype,
            • HTMLOutputElement.prototype,
            • HTMLParagraphElement.prototype,
            • HTMLParamElement.prototype,
            • HTMLPictureElement.prototype,
            • HTMLPreElement.prototype,
            • HTMLProgressElement.prototype,
            • HTMLQuoteElement.prototype,
            • HTMLScriptElement.prototype,
            • HTMLSelectElement.prototype,
            • HTMLShadowElement.prototype,
            • HTMLSourceElement.prototype,
            • HTMLSpanElement.prototype,
            • HTMLStyleElement.prototype,
            • HTMLTableCaptionElement.prototype,
            • HTMLTableCellElement.prototype,
            • HTMLTableColElement.prototype,
            • HTMLTableElement.prototype,
            • HTMLTableRowElement.prototype,
            • HTMLTableSectionElement.prototype,
            • HTMLTemplateElement.prototype,
            • HTMLTextAreaElement.prototype,
            • HTMLTitleElement.prototype,
            • HTMLTrackElement.prototype,
            • HTMLUListElement.prototype,
            • HTMLUnknownElement.prototype,
            • HTMLVideoElement.prototype,

ljbalgHml'DOM

Description:
DOM is a-specification of an-HML-document representation in ljb.

Name:
* cpt.ljb'DOM,
* cpt.ljbDOM,
* cpt.ljb'Document-Object-Model,
* cpt.ljbDocument-Object-Model,

Spec:
The-spec: https://www.w3.org/TR/domcore/

ljbalgHml'document-object

Description:
document is the-object that represents an-HML-document.
document is an-objectof HTMLDocument constructor-function.
document is an-instance of HTMLDocument.prototype.

Name:
* cpt.ljb'document,
* cpt.ljbdocument,
* cpt.ljb'document-object,
* cpt.ljbdocument-object,

Whole-chain:
* window, (window.document //#document)

Generic-chain:
* HTMLDocument.prototype,
* Document.prototype,
* Node.prototype,
* EventTarget.prototype,
* Object.prototype,

Member:
(Chrome.50):
> Object.getOwnPropertyNames(document).sort()
["location"]

(Firefox.46):
> Object.getOwnPropertyNames(document).sort()
["location"]

(Edge.20):
> Object.getOwnPropertyNames(document).sort()
["__IE_DEVTOOLBAR_CONSOLE_EVAL_ERROR", "__IE_DEVTOOLBAR_CONSOLE_EVAL_ERRORCODE", "__IE_DEVTOOLBAR_CONSOLE_EVAL_RESULT, "closure_lm_199280", "closure_lm_736068", "f"]

(Safari.5.1.7):
> Object.getOwnPropertyNames(document).sort()
["URL", "_html5shiv", "activeElement", "alinkColor", "all", "anchors", "applets", "attributes", "baseURI", "bgColor", "body", "characterSet", "charset", "childNodes", "compatMode", "constructor", "cookie", "defaultCharset", "defaultView", "designMode", "dir", "doctype", "documentElement", "documentURI", "domain", "embeds", "fgColor", "firstChild", "forms", "head", "height", "images", "implementation", "inputEncoding", "lastChild", "lastModified", "linkColor", "links", "localName", "location", "namespaceURI", "nextSibling", "nodeName", "nodeType", "nodeValue", "onabort", "onbeforecopy", "onbeforecut", "onbeforepaste", "onblur", "onchange", "onclick", "oncontextmenu", "oncopy", "oncut", "ondblclick", "ondrag", "ondragend", "ondragenter", "ondragleave", "ondragover", "ondragstart", "ondrop", "onerror", "onfocus", "oninput", "oninvalid", "onkeydown", "onkeypress", "onkeyup", "onload", "onmousedown", "onmousemove", "onmouseout", "onmouseover", "onmouseup", "onmousewheel", "onpaste", "onreadystatechange", "onreset", "onscroll", "onsearch", "onselect", "onselectionchange", "onselectstart", "onsubmit", "onwebkitfullscreenchange", "ownerDocument", "parentElement", "parentNode", "plugins", "preferredStylesheetSet", "prefix", "previousSibling", "readyState", "referrer", "scripts", "selectedStylesheetSet", "styleSheets", "textContent", "title", "vlinkColor", "webkitCurrentFullScreenElement", "webkitFullScreenKeyboardInputAllowed", "webkitIsFullScreen", "width", "xmlEncoding", "xmlStandalone", "xmlVersion"]

ljbalgHml'HTMLDocument.prototype

Description:
HTMLDocument.prototype is the-generic-object of document.
document is an-instance of HTMLDocument.prototype.
document is an-objectof HTMLDocument.

Name:
* cpt.ljb'HTMLDocument.prototype,
* cpt.ljbHTMLDocument.prototype,

Whole-chain:
* HTMLDocument-function,
* window,

Generic-chain:
* Document.prototype,
* Node.prototype,
* EventTarget.prototype,
* Object.prototype,

Member:
(Chrome.50):
> Object.getOwnPropertyNames(HTMLDocument.prototype).sort()
["alinkColor", "all", "bgColor", "captureEvents", "clear", "constructor", "fgColor", "linkColor", "releaseEvents", "vlinkColor"]

(Firefox.46):
> Object.getOwnPropertyNames(HTMLDocument.prototype).sort()
["alinkColor", "all", "anchors", "applets", "bgColor", "body", "captureEvents", "clear", "close", "constructor", "cookie", "designMode", "domain", "embeds", "execCommand", "fgColor", "forms", "getElementsByName", "getItems", "getSelection", "head", "images", "linkColor", "links", "open", "plugins", "queryCommandEnabled", "queryCommandIndeterm", "queryCommandState", "queryCommandSupported", "queryCommandValue", "releaseEvents", "scripts", "vlinkColor", "write", "writeln"]

(Edge.20):
> Object.getOwnPropertyNames(HTMLDocument.prototype).sort()
["constructor"]

(Safari.5.1.7):
> Object.getOwnPropertyNames(HTMLDocument.prototype).sort()
["captureEvents", "clear", "close", "hasFocus", "open", "releaseEvents", "write", "writeln"]

ljbalgHml'Document.prototype

Description:
Document.prototype is the-generic-object of any object created with the-Document-constructor-function.

Name:
* cpt.ljb'Document.prototype,
* cpt.ljbDocument.prototype,

Whole-chain:
* Document-function,
* window,

Generic-chain:
* Node.prototype,
* EventTarget.prototype,
* Object.prototype,

Member:
(Chrome.50):
> Object.getOwnPropertyNames(Document.prototype).sort()
["URL", "activeElement", "adoptNode", "anchors", "applets", "body", "caretRangeFromPoint", "characterSet", "charset", "childElementCount", "children", "close", "compatMode", "constructor", "contentType", "cookie", "createAttribute", "createAttributeNS", "createCDATASection", "createComment", "createDocumentFragment", "createElement", "createElementNS", "createEvent", "createExpression", "createNSResolver", "createNodeIterator", "createProcessingInstruction", "createRange", "createTextNode", "createTreeWalker", "currentScript", "defaultView", "designMode", "dir", "doctype", "documentElement", "documentURI", "domain", "elementFromPoint", "elementsFromPoint", "embeds", "evaluate", "execCommand", "exitPointerLock", "firstElementChild", "fonts", "forms", "getElementById", "getElementsByClassName", "getElementsByName", "getElementsByTagName", "getElementsByTagNameNS", "getSelection", "hasFocus", "head", "hidden", "images", "implementation", "importNode", "inputEncoding", "lastElementChild", "lastModified", "links", "onabort", "onautocomplete", "onautocompleteerror", "onbeforecopy", "onbeforecut", "onbeforepaste", "onblur", "oncancel", "oncanplay", "oncanplaythrough", "onchange", "onclick", "onclose", "oncontextmenu", "oncopy", "oncuechange", "oncut", "ondblclick", "ondrag", "ondragend", "ondragenter", "ondragleave", "ondragover", "ondragstart", "ondrop", "ondurationchange", "onemptied", "onended", "onerror", "onfocus", "oninput", "oninvalid", "onkeydown", "onkeypress", "onkeyup", "onload", "onloadeddata", "onloadedmetadata", "onloadstart", "onmousedown", "onmouseenter", "onmouseleave", "onmousemove", "onmouseout", "onmouseover", "onmouseup", "onmousewheel", "onpaste", "onpause", "onplay", "onplaying", "onpointerlockchange", "onpointerlockerror", "onprogress", "onratechange", "onreadystatechange", "onreset", "onresize", "onscroll", "onsearch", "onseeked", "onseeking", "onselect", "onselectionchange", "onselectstart", "onshow", "onstalled", "onsubmit", "onsuspend", "ontimeupdate", "ontoggle", "onvolumechange", "onwaiting", "onwebkitfullscreenchange", "onwebkitfullscreenerror", "onwheel", "open", "origin", "plugins", "pointerLockElement", "preferredStylesheetSet", "queryCommandEnabled", "queryCommandIndeterm", "queryCommandState", "queryCommandSupported", "queryCommandValue", "querySelector", "querySelectorAll", "readyState", "referrer", "registerElement", "rootElement", "scripts", "scrollingElement", "selectedStylesheetSet", "styleSheets", "title", "visibilityState", "webkitCancelFullScreen", "webkitCurrentFullScreenElement", "webkitExitFullscreen", "webkitFullscreenElement", "webkitFullscreenEnabled", "webkitHidden", "webkitIsFullScreen", "webkitVisibilityState", "write", "writeln", "xmlEncoding", "xmlStandalone", "xmlVersion"]

(Firefox.46):
> Object.getOwnPropertyNames(Document.prototype).sort()
["URL", "activeElement", "adoptNode", "caretPositionFromPoint", "characterSet", "charset", "childElementCount", "children", "compatMode", "constructor", "contentType", "createAttribute", "createAttributeNS", "createCDATASection", "createComment", "createDocumentFragment", "createElement", "createElementNS", "createEvent", "createExpression", "createNSResolver", "createNodeIterator", "createProcessingInstruction", "createRange", "createTextNode", "createTreeWalker", "currentScript", "defaultView", "dir", "doctype", "documentElement", "documentURI", "elementFromPoint", "elementsFromPoint", "enableStyleSheetsForSet", "evaluate", "firstElementChild", "fonts", "getElementById", "getElementsByClassName", "getElementsByTagName", "getElementsByTagNameNS", "hasFocus", "hidden", "implementation", "importNode", "inputEncoding", "lastElementChild", "lastModified", "lastStyleSheetSet", "mozCancelFullScreen", "mozExitPointerLock", "mozFullScreen", "mozFullScreenElement", "mozFullScreenEnabled", "mozHidden", "mozPointerLockElement", "mozSetImageElement", "mozVisibilityState", "onabort", "onafterscriptexecute", "onbeforescriptexecute", "onblur", "oncanplay", "oncanplaythrough", "onchange", "onclick", "oncontextmenu", "oncopy", "oncut", "ondblclick", "ondrag", "ondragend", "ondragenter", "ondragleave", "ondragover", "ondragstart", "ondrop", "ondurationchange", "onemptied", "onended", "onerror", "onfocus", "oninput", "oninvalid", "onkeydown", "onkeypress", "onkeyup", "onload", "onloadeddata", "onloadedmetadata", "onloadstart", "onmousedown", "onmouseenter", "onmouseleave", "onmousemove", "onmouseout", "onmouseover", "onmouseup", "onmozfullscreenchange", "onmozfullscreenerror", "onmozpointerlockchange", "onmozpointerlockerror", "onpaste", "onpause", "onplay", "onplaying", "onprogress", "onratechange", "onreadystatechange", "onreset", "onresize", "onscroll", "onseeked", "onseeking", "onselect", "onshow", "onstalled", "onsubmit", "onsuspend", "ontimeupdate", "onvolumechange", "onwaiting", "onwheel", "preferredStyleSheetSet", "querySelector", "querySelectorAll", "readyState", "referrer", "releaseCapture", "selectedStyleSheetSet", "styleSheetSets", "styleSheets", "title", "visibilityState"]

(Edge.20):
> Object.getOwnPropertyNames(Document.prototype).sort()
[190 members]

(Safari.5.1.7):
> Object.getOwnPropertyNames(Document.prototype).sort()
["adoptNode", "caretRangeFromPoint", "createAttribute", "createAttributeNS", "createCDATASection", "createComment", "createDocumentFragment", "createElement", "createElementNS", "createEntityReference", "createEvent", "createExpression", "createNSResolver", "createNodeIterator", "createProcessingInstruction", "createRange", "createTextNode", "createTreeWalker", "elementFromPoint", "evaluate", "execCommand", "getCSSCanvasContext", "getElementById", "getElementsByClassName", "getElementsByName", "getElementsByTagName", "getElementsByTagNameNS", "getOverrideStyle", "getSelection", "importNode", "queryCommandEnabled", "queryCommandIndeterm", "queryCommandState", "queryCommandSupported", "queryCommandValue", "querySelector", "querySelectorAll", "webkitCancelFullScreen"]

ljbalgHml'Node.prototype

Description:
Node.prototype is the-generic-object of any oNode objectof Node constructor-function.

Name:
* cpt.ljb'Node.prototype,
* cpt.ljbNode.prototype,

Whole-chain:
* Node-function,
* window,

Generic-chain:
* EventTarget.prototype,
* Object.prototype,

Member:
(Chrome.50):
> Object.getOwnPropertyNames(Node.prototype).sort()
["ATTRIBUTE_NODE", "CDATA_SECTION_NODE", "COMMENT_NODE", "DOCUMENT_FRAGMENT_NODE", "DOCUMENT_NODE", "DOCUMENT_POSITION_CONTAINED_BY", "DOCUMENT_POSITION_CONTAINS", "DOCUMENT_POSITION_DISCONNECTED", "DOCUMENT_POSITION_FOLLOWING", "DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC", "DOCUMENT_POSITION_PRECEDING", "DOCUMENT_TYPE_NODE", "ELEMENT_NODE", "ENTITY_NODE", "ENTITY_REFERENCE_NODE", "NOTATION_NODE", "PROCESSING_INSTRUCTION_NODE", "TEXT_NODE", "appendChild", "baseURI", "childNodes", "cloneNode", "compareDocumentPosition", "constructor", "contains", "firstChild", "hasChildNodes", "insertBefore", "isDefaultNamespace", "isEqualNode", "isSameNode", "lastChild", "lookupNamespaceURI", "lookupPrefix", "nextSibling", "nodeName", "nodeType", "nodeValue", "normalize", "ownerDocument", "parentElement", "parentNode", "previousSibling", "removeChild", "replaceChild", "textContent"]

(Firefox.46):
> Object.getOwnPropertyNames(Node.prototype).sort()
["ATTRIBUTE_NODE", "CDATA_SECTION_NODE", "COMMENT_NODE", "DOCUMENT_FRAGMENT_NODE", "DOCUMENT_NODE", "DOCUMENT_POSITION_CONTAINED_BY", "DOCUMENT_POSITION_CONTAINS", "DOCUMENT_POSITION_DISCONNECTED", "DOCUMENT_POSITION_FOLLOWING", "DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC", "DOCUMENT_POSITION_PRECEDING", "DOCUMENT_TYPE_NODE", "ELEMENT_NODE", "ENTITY_NODE", "ENTITY_REFERENCE_NODE", "NOTATION_NODE", "PROCESSING_INSTRUCTION_NODE", "TEXT_NODE", "appendChild", "baseURI", "childNodes", "cloneNode", "compareDocumentPosition", "constructor", "contains", "firstChild", "hasChildNodes", "insertBefore", "isDefaultNamespace", "isEqualNode", "lastChild", "localName", "lookupNamespaceURI", "lookupPrefix", "namespaceURI", "nextSibling", "nodeName", "nodeType", "nodeValue", "normalize", "ownerDocument", "parentElement", "parentNode", "prefix", "previousSibling", "removeChild", "replaceChild", "textContent"]

(Edge.20):
> Object.getOwnPropertyNames(Node.prototype).sort()
[51 members]

(Safari.5.1.7):
> Object.getOwnPropertyNames(Node.prototype).sort()
["adoptNode", "caretRangeFromPoint", "createAttribute", "createAttributeNS", "createCDATASection", "createComment", "createDocumentFragment", "createElement", "createElementNS", "createEntityReference", "createEvent", "createExpression", "createNSResolver", "createNodeIterator", "createProcessingInstruction", "createRange", "createTextNode", "createTreeWalker", "elementFromPoint", "evaluate", "execCommand", "getCSSCanvasContext", "getElementById", "getElementsByClassName", "getElementsByName", "getElementsByTagName", "getElementsByTagNameNS", "getOverrideStyle", "getSelection", "importNode", "queryCommandEnabled", "queryCommandIndeterm", "queryCommandState", "queryCommandSupported", "queryCommandValue", "querySelector", "querySelectorAll", "webkitCancelFullScreen"]

Specific:
* Attr.prototype,
* CharacterData.prototype,
* Document.prototype,
* DocumentFragment.prototype,
* DocumentType.prototype,
* Element.prototype,

ljbalgHml'Attr.prototype

Description:
Attr.prototype is the-generic-object of oAttr[1] objectof Attr constructor, which[1] represents HML-attributes.

Name:
* cpt.ljb'Attr.prototype,
* cpt.ljbAttr.prototype,

Whole-chain:
* Attr-function,
* window,

Generic-chain:
* Node.prototype, (Attr.prototype.__proto__ === Node.prototype //true)
* EventTarget.prototype,
* Object.prototype,

Member:
(Chrome.50):
> Object.getOwnPropertyNames(Attr.prototype).sort()
["constructor", "localName", "name", "namespaceURI", "nodeValue", "ownerElement", "prefix", "specified", "textContent", "value"]

(Firefox.46):
> Object.getOwnPropertyNames(Attr.prototype).sort()
["constructor", "localName", "name", "namespaceURI", "ownerElement", "prefix", "specified", "value"]

(Edge.20):
> Object.getOwnPropertyNames(Attr.prototype).sort()
[]

(Safari.5.1.7):
> Object.getOwnPropertyNames(Attr.prototype).sort()
[]

Specific:
*

ljbalgHml'CharacterData.prototype

Description:
CharacterData.prototype is the-generic-object of Comment.prototype and Text.prototype.

Name:
* cpt.ljb'CharacterData.prototype,
* cpt.ljbCharacterData.prototype,

Whole-chain:
* CharacterData-function,
* window,

Generic-chain:
* Node.prototype,
* EventTarget.prototype,
* Object.prototype,

Member:
(Chrome.50):
> Object.getOwnPropertyNames(CharacterData.prototype).sort()
["appendData", "constructor", "data", "deleteData", "insertData", "length", "nextElementSibling", "previousElementSibling", "remove", "replaceData", "substringData"]

(Firefox.46):
> Object.getOwnPropertyNames(CharacterData.prototype).sort()
["appendData", "constructor", "data", "deleteData", "insertData", "length", "nextElementSibling", "previousElementSibling", "remove", "replaceData", "substringData"]

(Edge.20):
> Object.getOwnPropertyNames(CharacterData.prototype).sort()
[]

(Safari.5.1.7):
> Object.getOwnPropertyNames(CharacterData.prototype).sort()
[]

Specific:
* Comment.prototype,
* Text.prototype,

ljbalgHml'DocumentFragment.prototype

Description:
DocumentFragment.prototype is the-generic-object of oDocumentFragment[1] objectof DocumentFragment constructor, which[1] represents a PART of an-HML-document.
Using oDocumentFragments instead of the whole HML-document (document) increases processing speed.

Name:
* cpt.ljb'DocumentFragment.prototype,
* cpt.ljbDocumentFragment.prototype,

Whole-chain:
* DocumentFragment-function,
* window,

Generic-chain:
* Node.prototype,
* EventTarget.prototype,
* Object.prototype,

Member:
(Chrome.50):
> Object.getOwnPropertyNames(DocumentFragment.prototype).sort()
["childElementCount", "children", "constructor", "firstElementChild", "getElementById", "lastElementChild", "querySelector", "querySelectorAll"]

(Firefox.46):
> Object.getOwnPropertyNames(DocumentFragment.prototype).sort()
["childElementCount", "children", "constructor", "firstElementChild", "getElementById", "lastElementChild", "querySelector", "querySelectorAll"]

(Edge.20):
> Object.getOwnPropertyNames(DocumentFragment.prototype).sort()
[]

(Safari.5.1.7):
> Object.getOwnPropertyNames(DocumentFragment.prototype).sort()
[]

Specific:
* oDocumentFragment,

ljbalgHml'DocumentType.prototype

Description:
DocumentType.prototype is the-generic-object of oDocumentType[1] objectof DocumentType constructor, which[1] represents a-doctype HML-element.

Name:
* cpt.ljb'DocumentType.prototype,
* cpt.ljbDocumentType.prototype,

Whole-chain:
* DocumentType-function,
* window,

Generic-chain:
* Node.prototype,
* EventTarget.prototype,
* Object.prototype,

Member:
(Chrome.50):
> Object.getOwnPropertyNames(DocumentType.prototype).sort()
["constructor", "name", "publicId", "remove", "systemId"]

(Firefox.46):
> Object.getOwnPropertyNames(DocumentType.prototype).sort()
["constructor", "name", "publicId", "remove", "systemId"]

(Edge.20):
> Object.getOwnPropertyNames(DocumentType.prototype).sort()
[]

(Safari.5.1.7):
> Object.getOwnPropertyNames(DocumentType.prototype).sort()
[]

Specific:
* oDocumentType,

ljbalgHml'Element.prototype

Description:
Element.prototype[1] is the-generic-object of HTMLElement.prototype.
It[1] contains important members for the-objects that represent HML-elements.

Name:
* cpt.ljb'Element.prototype,
* cpt.ljbElement.prototype,

Whole-chain:
* Element-function,
* window,

Generic-chain:
* Node.prototype,
* EventTarget.prototype,
* Object.prototype,

Member:
(Chrome.50):
> Object.getOwnPropertyNames(Element.prototype).sort()
["animate", "attributes", "childElementCount", "children", "classList", "className", "clientHeight", "clientLeft", "clientTop", "clientWidth", "closest", "constructor", "createShadowRoot", "firstElementChild", "getAttribute", "getAttributeNS", "getAttributeNode", "getAttributeNodeNS", "getBoundingClientRect", "getClientRects", "getDestinationInsertionPoints", "getElementsByClassName", "getElementsByTagName", "getElementsByTagNameNS", "hasAttribute", "hasAttributeNS", "hasAttributes", "id", "innerHTML", "insertAdjacentElement", "insertAdjacentHTML", "insertAdjacentText", "lastElementChild", "localName", "matches", "namespaceURI", "nextElementSibling", "onbeforecopy", "onbeforecut", "onbeforepaste", "oncopy", "oncut", "onpaste", "onsearch", "onselectstart", "onwebkitfullscreenchange", "onwebkitfullscreenerror", "onwheel", "outerHTML", "prefix", "previousElementSibling", "querySelector", "querySelectorAll", "remove", "removeAttribute", "removeAttributeNS", "removeAttributeNode", "requestPointerLock", "scrollHeight", "scrollIntoView", "scrollIntoViewIfNeeded", "scrollLeft", "scrollTop", "scrollWidth", "setAttribute", "setAttributeNS", "setAttributeNode", "setAttributeNodeNS", "shadowRoot", "tagName", "webkitMatchesSelector", "webkitRequestFullScreen", "webkitRequestFullscreen"]

(Firefox.46):
> Object.getOwnPropertyNames(Element.prototype).sort()
["attributes", "childElementCount", "children", "classList", "className", "clientHeight", "clientLeft", "clientTop", "clientWidth", "closest", "constructor", "firstElementChild", "getAttribute", "getAttributeNS", "getAttributeNames", "getAttributeNode", "getAttributeNodeNS", "getBoundingClientRect", "getClientRects", "getElementsByClassName", "getElementsByTagName", "getElementsByTagNameNS", "hasAttribute", "hasAttributeNS", "hasAttributes", "id", "innerHTML", "insertAdjacentHTML", "lastElementChild", "matches", "mozMatchesSelector", "mozRequestFullScreen", "mozRequestPointerLock", "nextElementSibling", "onwheel", "outerHTML", "previousElementSibling", "querySelector", "querySelectorAll", "releaseCapture", "remove", "removeAttribute", "removeAttributeNS", "removeAttributeNode", "scroll", "scrollBy", "scrollHeight", "scrollIntoView", "scrollLeft", "scrollLeftMax", "scrollTo", "scrollTop", "scrollTopMax", "scrollWidth", "setAttribute", "setAttributeNS", "setAttributeNode", "setAttributeNodeNS", "setCapture", "tagName", "webkitMatchesSelector"]

(Edge.20):
> Object.getOwnPropertyNames(Element.prototype).sort()
[]

(Safari.5.1.7):
> Object.getOwnPropertyNames(Element.prototype).sort()
[]

Specific:
* HTMLElement.prototype,

ljbalgHml'HTMLElement.prototype

Description:
HTMLElement.prototype[1] is the-generic-object of the-objects that represent HML-elements.

Name:
* cpt.ljb'HTMLElement.prototype,
* cpt.ljbHTMLElement.prototype,

Whole-chain:
* HTMLElement-function,
* window,

Generic-chain:
* Element.prototype,
* Node.prototype,
* EventTarget.prototype,
* Object.prototype,

Member:
(Chrome.50):
> Object.getOwnPropertyNames(HTMLElement.prototype).sort()
["accessKey", "blur", "click", "constructor", "contentEditable", "dataset", "dir", "draggable", "focus", "hidden", "innerText", "isContentEditable", "lang", "offsetHeight", "offsetLeft", "offsetParent", "offsetTop", "offsetWidth", "onabort", "onautocomplete", "onautocompleteerror", "onblur", "oncancel", "oncanplay", "oncanplaythrough", "onchange", "onclick", "onclose", "oncontextmenu", "oncuechange", "ondblclick", "ondrag", "ondragend", "ondragenter", "ondragleave", "ondragover", "ondragstart", "ondrop", "ondurationchange", "onemptied", "onended", "onerror", "onfocus", "oninput", "oninvalid", "onkeydown", "onkeypress", "onkeyup", "onload", "onloadeddata", "onloadedmetadata", "onloadstart", "onmousedown", "onmouseenter", "onmouseleave", "onmousemove", "onmouseout", "onmouseover", "onmouseup", "onmousewheel", "onpause", "onplay", "onplaying", "onprogress", "onratechange", "onreset", "onresize", "onscroll", "onseeked", "onseeking", "onselect", "onshow", "onstalled", "onsubmit", "onsuspend", "ontimeupdate", "ontoggle", "onvolumechange", "onwaiting", "outerText", "spellcheck", "style", "tabIndex", "title", "translate", "webkitdropzone"]

(Firefox.46):
> Object.getOwnPropertyNames(HTMLElement.prototype).sort()
["accessKey", "accessKeyLabel", "blur", "click", "constructor", "contentEditable", "contextMenu", "dataset", "dir", "draggable", "focus", "hidden", "innerText", "isContentEditable", "itemId", "itemProp", "itemRef", "itemScope", "itemType", "itemValue", "lang", "offsetHeight", "offsetLeft", "offsetParent", "offsetTop", "offsetWidth", "onabort", "onblur", "oncanplay", "oncanplaythrough", "onchange", "onclick", "oncontextmenu", "oncopy", "oncut", "ondblclick", "ondrag", "ondragend", "ondragenter", "ondragleave", "ondragover", "ondragstart", "ondrop", "ondurationchange", "onemptied", "onended", "onerror", "onfocus", "oninput", "oninvalid", "onkeydown", "onkeypress", "onkeyup", "onload", "onloadeddata", "onloadedmetadata", "onloadstart", "onmousedown", "onmouseenter", "onmouseleave", "onmousemove", "onmouseout", "onmouseover", "onmouseup", "onmozfullscreenchange", "onmozfullscreenerror", "onmozpointerlockchange", "onmozpointerlockerror", "onpaste", "onpause", "onplay", "onplaying", "onprogress", "onratechange", "onreset", "onresize", "onscroll", "onseeked", "onseeking", "onselect", "onshow", "onstalled", "onsubmit", "onsuspend", "ontimeupdate", "onvolumechange", "onwaiting", "properties", "spellcheck", "style", "tabIndex", "title"]

(Edge.20):
> Object.getOwnPropertyNames(Element.prototype).sort()
[]

(Safari.5.1.7):
> Object.getOwnPropertyNames(HTMLElement.prototype).sort()
[]

Specific:
* HTMLAnchorElement.prototype,
** oHTMLAnchorElement,
* HTMLAreaElement.prototype,
** oHTMLAreaElement,
* HTMLAudioElement.prototype,
** oHTMLAudioElement,
* HTMLBRElement.prototype,
** oHTMLBRElement,
* HTMLBaseElement.prototype,
** oHTMLBaseElement,
* HTMLBodyElement.prototype,
** oHTMLBodyElement,
* HTMLButtonElement.prototype,
** oHTMLButtonElement,
* HTMLCanvasElement.prototype,
** oHTMLCanvasElement,
* HTMLContentElement.prototype,
** oHTMLContentElement,
* HTMLDListElement.prototype,
** oHTMLDListElement,
* HTMLDataListElement.prototype,
** oHTMLDataListElement,
* HTMLDetailsElement.prototype,
** oHTMLDetailsElement,
* HTMLDialogElement.prototype,
** oHTMLDialogElement,
* HTMLDirectoryElement.prototype,
** oHTMLDirectoryElement,
* HTMLDivElement.prototype,
** oHTMLDivElement,
* HTMLEmbedElement.prototype,
** oHTMLEmbedElement,
* HTMLFieldSetElement.prototype,
** oHTMLFieldSetElement,
* HTMLFontElement.prototype,
** oHTMLFontElement,
* HTMLFormElement.prototype,
** oHTMLFormElement,
* HTMLFrameElement.prototype,
** oHTMLFrameElement,
* HTMLFrameSetElement.prototype,
** oHTMLFrameSetElement,
* HTMLHRElement.prototype,
** oHTMLHRElement,
* HTMLHeadElement.prototype,
** oHTMLHeadElement,
* HTMLHeadingElement.prototype,
** oHTMLHeadingElement,
* HTMLHtmlElement.prototype,
** oHTMLHtmlElement,
* HTMLIFrameElement.prototype,
** oHTMLIFrameElement,
* HTMLImageElement.prototype,
** oHTMLImageElement,
* HTMLInputElement.prototype,
** oHTMLInputElement,
* HTMLKeygenElement.prototype,
** oHTMLKeygenElement,
* HTMLLIElement.prototype,
** oHTMLLIElement,
* HTMLLabelElement.prototype,
** oHTMLLabelElement,
* HTMLLegendElement.prototype,
** oHTMLLegendElement,
* HTMLLinkElement.prototype,
** oHTMLLinkElement,
* HTMLMapElement.prototype,
** oHTMLMapElement,
* HTMLMarqueeElement.prototype,
** oHTMLMarqueeElement,
* HTMLMediaElement.prototype,
** oHTMLMediaElement,
* HTMLMenuElement.prototype,
** oHTMLMenuElement,
* HTMLMetaElement.prototype,
** oHTMLMetaElement,
* HTMLMeterElement.prototype,
** oHTMLMeterElement,
* HTMLModElement.prototype,
** oHTMLModElement,
* HTMLOListElement.prototype,
** oHTMLOListElement,
* HTMLObjectElement.prototype,
** oHTMLObjectElement,
* HTMLOptGroupElement.prototype,
** oHTMLOptGroupElement,
* HTMLOptionElement.prototype,
** oHTMLOptionElement,
* HTMLOptionsCollection.prototype,
** oHTMLOptionsCollection,
* HTMLOutputElement.prototype,
** oHTMLOutputElement,
* HTMLParagraphElement.prototype,
** oHTMLParagraphElement,
* HTMLParamElement.prototype,
** oHTMLParamElement,
* HTMLPictureElement.prototype,
** oHTMLPictureElement,
* HTMLPreElement.prototype,
** oHTMLPreElement,
* HTMLProgressElement.prototype,
** oHTMLProgressElement,
* HTMLQuoteElement.prototype,
** oHTMLQuoteElement,
* HTMLScriptElement.prototype,
** oHTMLScriptElement,
* HTMLSelectElement.prototype,
** oHTMLSelectElement,
* HTMLShadowElement.prototype,
** oHTMLShadowElement,
* HTMLSourceElement.prototype,
** oHTMLSourceElement,
* HTMLSpanElement.prototype,
** oHTMLSpanElement,
* HTMLStyleElement.prototype,
** oHTMLStyleElement,
* HTMLTableCaptionElement.prototype,
** oHTMLTableCaptionElement,
* HTMLTableCellElement.prototype,
** oHTMLTableCellElement,
* HTMLTableColElement.prototype,
** oHTMLTableColElement,
* HTMLTableElement.prototype,
** oHTMLTableElement,
* HTMLTableRowElement.prototype,
** oHTMLTableRowElement,
* HTMLTableSectionElement.prototype,
** oHTMLTableSectionElement,
* HTMLTemplateElement.prototype,
** oHTMLTemplateElement,
* HTMLTextAreaElement.prototype,
** oHTMLTextAreaElement,
* HTMLTitleElement.prototype,
** oHTMLTitleElement,
* HTMLTrackElement.prototype,
** oHTMLTrackElement,
* HTMLUListElement.prototype,
** oHTMLUListElement,
* HTMLUnknownElement.prototype,
** oHTMLUnknownElement,
* HTMLVideoElement.prototype,
** oHTMLVideoElement,

ljb'Binary-code

Generic:
* ljs-binary-code,

Name:
* cpt.ljb'binary-code,
* cpt.ljbbinary-code,
* cpt.ljb'bcode,
* cpt.ljbbcode,

ljb'Evaluation

Generic:
* ljs-evaluation,

Name:
* cpt.ljb'evaluation,
* cpt.ljbevaluation,

ljb'Pro

Simplicity:
Its code is-created FROM only 11 semantic-units.

ljb'Con

Whole-Part-management (modules):
Ljb lacks a-mechanism of organizing its semantic-units into parts.
Like the 'prototype-inheritance' mechanism which manages the generic-specific relations, we need and a-mechanism to manage the whole-part relations.
Today, all its-constructs loaded from js-files reside, in a-mess, inside the-most-whole-object (global).
Now we can-create collections only with objects and arrays.
ECMAScript.6.2015 spec added this mechanism, but it is not implemented by the-browsers.

ljb'Tool

Generic:
* ljs-tool,

Name:
* cpt.ljb'tool,
* cpt.ljbtool,

Resource:
* Chrome DevTools,
* Firebug,

ljb'tool.Browser

Description:
Browser is the-program that displays webpages (understands HML and CSS code) and executes ljb code.

Name:
* cpt.ljb'browser,
* cpt.ljbbrowser,
* cpt.ljb'webbrowser,
* cpt.ljbwebbrowser,
* cpt.browser,
* browser-cpt,
* webbrowser-cpt,

ljbbrowser'Engine.Layout

Description:
Layout-engine is the-component of the-browser-program that reads and displays the-HML and CSS code of a-webpage.

Name:
* cpt.browser-layout-engine,
* cpt.browser-rendering-engine,
* cpt.layout-engine-of-browser,
* cpt.rendering-engine-of-browser,

Specific:
* Blink (Chrome >28, Opera >15)
* EdgeHTML (Edge),
* Gecko (Firefox),
* WebKit,

ljbbrowser'Engine.javascript

Description:
Ljb-engine is the-component of the-browser-program that reads and executes the-code.

Name:
* cpt.ljb'engine,
* cpt.ljbengine,
* cpt.ljb'implementation,
* cpt.ljbimplementation,
* cpt.ljb'interpreter,
* cpt.ljbinterpreter,
* cpt.ljb'runtime,
* cpt.ljbruntime,

Specific:
* SpiderMondey (Firefox),
* V8 (Chrome),

ljbbrowser'Webpage

Description:
Webpage is an-HML-document, plus all other files needed, such as images, video, CSS, ljb, etc.
Browsers display webpages.

Name:
* cpt.web-page,
* cpt.webpage,

Part:
* HML-code,
* CSS-code,
* Ljb-code,
* media-files,

ljbbrowser.SPECIFIC

Specific:
* Google-Chrome,
* Microsoft-Edge,
* Mozilla-Firefox,
* Safari,
* Opera,
===
* Desktop-browser,
* Mobile-browser,

ljb'tool.Testing

Generic:
* ljs-testing-tool,

Name:
* cpt.ljb'tool.testing,
* cpt.ljb'testing-tool,
* ljb'tool.testing-cpt,
* ljb'testing-tool-cpt,

Resource:
* https://saucelabs.com/, Accelerate your software development and bring your great ideas to market faster with the world's largest automated testing cloud for web and mobile apps.

ljs.Node-javascript (ljn, Node.js) {2009}

ljn'Description

The-Node.js-language (ljn) is a-javascript-language that is-understood by the-Node.js-runtime.
[HmnSynagonism.2016-07-01]
===
Node.js® is a javascript runtime built on Chrome's V8 javascript engine.
Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient.
Node.js' package ecosystem, npm, is the largest ecosystem of open source libraries in the world.

[https://nodejs.org/en/]
===
Node.js is a server-side javascript environment that uses an asynchronous event-driven model.
This allows Node.js to get excellent performance based on the architectures of many Internet applications.

[https://github.com/joyent/node/wiki]
===
Ignore the name: Node.js isn't a javascript library.
Instead, Node.js is a javascript interpreter (powered by V8, the engine used by Google's Chrome browser) that interfaces with the underlying operating system.
That way, javascript run by Node.js can read and write files, spawn processes, and—most enticingly—send and receive HTTP requests.

[http://media.pragprog.com/titles/tbcoffee/server.pdf]
===
An important thing to realize is that Node is not a webserver.
By itself it doesn't do anything.
It doesn't work like Apache.
There is no config file where you point it to you HTML files.
If you want it to be a HTTP server, you have to write an HTTP server (with the help of its built-in libraries).
Node.js is just another way to execute code on your computer.
It is simply a javascript runtime.

[http://blog.modulus.io/absolute-beginners-guide-to-nodejs]
===
Node.js is a platform built on Chrome's javascript runtime for easily building fast, scalable network applications.
Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient, perfect for data-intensive real-time applications that run across distributed devices.

[http://nodejs.org/]
===
Node is a javascript environment running in Google's V8 javascript engine.
[http://net.tutsplus.com/tutorials/javascript-ajax/node-js-for-beginners/]
===
Joyent is the corporate steward of Node.js, the world's best runtime for today's data-intensive, real-time applications.
Joyent offers exclusive debugging and performance analysis tools for Node.js applications.

[https://www.joyent.com/technology/nodejs]
===
Node.js is a native javascript server application running right up against the OS.
Node.js builds directly on Chrome V8 and uses event-driven, asynchronous javascript to create a very distinctive development environment.
Node.js has very few dependencies, runs very fast, and has a very active community.
Most of all, its fun!
I ported the Google Wave Gadget API implementation from Apache Wookie over to Node.js in a couple of days (you can download it here).
Node also seems to use very little memory regardless of demand - this is due to it using a threadless, event driven server model rather than a more traditional thread pool approach.
On the downside, there is some skepticism of the hype around the speed of Node.js.
Also, while being very lightweight has its advantages, being so close to the OS makes it harder to manage and track server performance without a lot of Linux Jujitsu: there are, as yet, no simple graphical management tools or utilities for handling deployed applications, for example.
However, if you need a platform to prototype demanding real-time applications such as multiplayer games then Node.js is well worth looking at.

[http://zope.cetis.ac.uk/members/scott/blogview?entry=20110124133546]
===
Node.js is an event-driven I/O framework for the V8 javascript engine on Unix-like platforms.
It is intended for writing scalable network programs such as web servers[1].
It was created by Ryan Dahl in 2009, and its growth is sponsored by Joyent, which employs Dahl[2].
Node.js is similar in purpose to Twisted for Python, Perl Object Environment for Perl, and EventMachine for Ruby.
Unlike most javascript, it is not executed in a web browser, but it is rather related to server-side javascript.
Node.js implements some CommonJS specifications[3].
Node.js includes a REPL environment for interactive testing.

[http://en.wikipedia.org/wiki/Node.js]

ljn'Name

Name:
* cpt.Node.js,
* cpt.Node.js-language,
* cpt.Node-javascript,
* cpt.language.javascript.Node.js,
* cpt.languagejavascriptNode.js,
* lcpNodejs-cpt,
* NodeJS-cpt,
* Node-cpt,
* Node.js-cpt,
* ssjs'Node.js,
=== Abbreviation:
* cpt.ljn,
* ljn-cpt,
* ljn, {2016.05.27}
* lnj, {2016.05.10}
* ljsNd-cpt, {2014.02.16}
* ndjs-cpt,

ljn'Archetype

Description:
NodeJs is a perfect candidate for real time communication over internet.
[https://www.quora.com/What-are-the-pros-and-cons-of-Node-js-versus-Apache-web-server] ===
Node.js had an extraordinary year so far: npm already hit 4 million users and processes a billion downloads a week, while major enterprises adopt the language as the main production framework day by day.
[https://blog.risingstack.com/node-js-examples-how-enterprises-use-node-in-2016/]

Name:
* cpt.ljn'usage,

Generic:
* ljs-archetype,

AddressWpg:
* https://blog.risingstack.com/node-js-examples-how-enterprises-use-node-in-2016/

ljn'Algorithm (Model)

Generic:
* ljn-algorithm,

Name:
* cpt.ljn'algorithm,
* cpt.ljn'algo,
* cpt.ljnalgo, {2014.03.10}
===
* cpt.ljnalgo,
* ljnalgo-cpt,

ljnalgo'code

Generic:
* ljs-code,

Name:
* cpt.ljn'code,
* cpt.ljncode,

Part:
* dir-of-code,
* file-of-code,

ljncode'File

Description:
So far we've only been using a single file, which isn't very maintainable.
In most applications your code will be split into several files.
There's no standard or enforced organization to what files go where.
This isn't Rails.
There's no concept of views go here and controllers go there.
You can do whatever you want.

[http://blog.modulus.io/absolute-beginners-guide-to-nodejs]

ljnalgo'doing.TESTING (link)

ljnalgo'mistake

AddressWpg:
* https://www.airpair.com/node.js/posts/top-10-mistakes-node-developers-make,

ljnalgo'UNIT

Generic:
* ljs-unit,

Name:
* cpt.ljn'unit,
* cpt.ljnunit,

ljnalgo'WORD

Generic:
* ljs-word,

Name:
* cpt.ljn'word,
* cpt.ljnword,

ljnalgo'SEMANTIC-UNIT (ljnsut)

Generic:
* ljs-semantic-unit,

Name:
* cpt.ljn'semantic-unit,
* cpt.ljnsemantic-unit,
* cpt.ljn'sut,
* cpt.ljnsut,
* ljn'semantic-unit-cpt,
* ljnsemantic-unit-cpt,
* ljn'sut-cpt,
* ljnsut-cpt,

ljnsut.SPECIFIC

Specific:
See ljb-specific-semantic-unit.
01) a - Array,
02) b - Boolean,
03) f - Function,
04) l - nuLl,
05) m - Module,
06) n - Number,
07) o - Object,
08) r - Regexp,
09) s - String,
10) u - Undefined,
11) v - name-Value-pair,
12) x - miXed,

ljnsut.FUNCTION

Description:
Because javascript is event-oriented rather than thread-oriented, events only run when all other execution has stopped.
Imagine how frustrating it would be if every time your application made a request (say, to the file system or to an HTTP server), it froze up completely until the request was completed!
For that reason, nearly every function in the Node.js API uses a callback:
you make your request, Node.js quickly passes it along, and your application continues as if nothing happened.
When your request is completed (or goes awry), the function you passed to Node.js gets called.

[http://media.pragprog.com/titles/tbcoffee/server.pdf]

Name:
* cpt.ljn'function,
* cpt.ljnfunction,
* cpt.ljnf,

Generic:
* ljs-function.

ljnf.ASYNCHRONOUS

Description:
Node API is not all asynchronous.
Some parts of it are synchronous but they are very well marked: they always terminate in "Sync" - lik fs.readFileSync...
One function that is synchronous and does not end in Sync is 'require' which should only be used when initializing an app or module.

[http://nodetuts.com/pdf/handson-nodejs-sample.pdf 30/147]

ljnsut.OBJECT (ljno)

Generic:
* ljs-object,

Name:
* cpt.ljn'object,
* cpt.ljnobject,
* cpt.ljno,

ljnsut.NAME-VALUE-PAIR

Generic:
* ljs-name-value-pair,

Name:
* cpt.ljn'name-value-pair,
* cpt.ljn'nvp,
* cpt.ljnnvp,
* cpt.ljnv,

ljnalgo'sut.MODULE (ljnm)

Description:
Module is a-semantic-unit which CONTAINS other semantic-units.
Like the-'prototype-inheritance' mechanism which manages the generic-specific relations of semantic-units, modules is the-mechanism needed to manage the whole-part relations.
In contrast to objects, modules HAVE scope, ie its members see each other.

Name:
* cpt.ljn'module,
* cpt.ljn'module-semantic-unit,
* cpt.ljn'module-sut,
* cpt.ljn'library,
* cpt.ljnmodule,
* nodejs'library-cpt,
* nodejs'module-cpt,
===
* cpt.ljnm, {2016.06.27}
* ljnm-cpt,
* cpt.ljnmdl, {2016.06.14}
* ljnmdl-cpt,
===
NOTATION: I name the-modules as 'mName' if they export objects and 'm?Name' where ? = a,b,f,n,r,s if they export other semantic-units. [synagonism.2016-07-25]

Generic:
* CommonJS-module,

ljnm'Description

Description:
Do-NOT-confuse the-module-semantic-unit (this-concept), with the-module-object, which is a-member of any module-semantic-unit.
[HmnSynagonism.2016-07-23]
===
Module is an OBJECT importing/exporting from a file or directory code-structure.
It can have explicitly defined properties with 'exports.property' code
or it can be a single exported function/object with the 'module.exports' code.
[HmnSynagonism.2014-04-22]
===
Modules make it possible to include other Javascript files into your applications.
... Modules are crucial to building applications in Node, as they allow you to include external libraries, such as database access libraries - and they help in organizing your code into separate parts with limited responsibilities.
You should try to identify reusable parts in your own code and turn them into separate modules to reduce the amount of code per file and to make it easier to read and maintain your code.

[http://book.mixu.net/node/single.html]
===
Node has a simple module loading system.
In Node, files and modules are in one-to-one correspondence.

[https://nodejs.org/docs/v6.3.1/api/modules.html#modules_modules]
===
Node.js uses a module architecture to simplify the creation of complex applications.
Modules are akin to libraries in C, or units in Pascal.
Each module contains a set of functions related to the “subject” of the module.
For example, the http module contains functions specific to HTTP.
Node.js provides a few core modules out of the box to help you access files on the file system, create HTTP and TCP/UDP servers, and perform other useful functions.
Including a module is easy; simply call the require() function, like this:
> var http = require('http');
The require() function returns the reference to the specified module.
In the case of this code, a reference to the http module is stored in the http variable.

[http://net.tutsplus.com/tutorials/javascript-ajax/node-js-for-beginners/]

ljnm'Caching

Description:
Caching
Modules are cached after the first time they are loaded.
This means (among other things) that every call to require('foo') will get exactly the same object returned, if it would resolve to the same file.

Multiple calls to require('foo') may not cause the module code to be executed multiple times.
This is an important feature.
With it, "partially done" objects can be returned, thus allowing transitive dependencies to be loaded even when they would cause cycles.

If you want to have a module execute code multiple times, then export a function, and call that function.

Module Caching Caveats
Modules are cached based on their resolved filename.
Since modules may resolve to a different filename based on the location of the calling module (loading from node_modules folders), it is not a guarantee that require('foo') will always return the exact same object, if it would resolve to different files.

[http://nodejs.org/api/modules.html#modules_caching]

Name:
* cpt.ljnm'caching,
* cpt.ljn'module-caching,

ljnm'member

Description:
Member-of-module is a-semantic-unit CONTAINED by the-module.

Name:
* cpt.ljnm'member,
* cpt.ljn'module-member,

ljnmmbr'exporting

Description:
The-object module.exports is the-semantic-unit a-module exports, the-public semantic-unit of a-module.

Name:
* cpt.ljnm'exporting,
* cpt.ljnm'exposing,

ljnmmbr'importing

Description:
We can-import the-public-semantic-unit of a-module, in any other module.
To do it, we use the-function require().

Name:
* cpt.ljnm'importing,
* cpt.ljnm'loading,
* cpt.ljnm'requiring,
* cpt.ljnm'using,

ljnmmbr.SPECIFIC

Specific:
* public-member,
* publicNo-member,
===
* __dirname-string-member,
* __filename-string-member,
* module-object-member,
* require-function-member,

ljnmmbr.PUBLIC

Description:
Public-member-of-module is an-exported member, that we have access outside of the-module.
A-module, as a-self-executing-function, returns|exports ONLY ONE semantic-unit.
When we export many members like exports.member = value, we export one object with members the-ones we denote in exports.

Name:
* cpt.ljnm'exported-member,
* cpt.ljnm'public-member,
* cpt.ljnm'member.public,
* cpt.ljnm'member.localNo,
* cpt.ljnm'member.privateNo,
* cpt.ljnmmbr.public,

ljnmmbr.PUBLIC.NO

Description:
In browsers, the top-level scope is the global scope.
That means that in browsers if you're in the global scope var something will define a global variable.
In Node.js this is different.
The top-level scope is not the global scope; var something inside an Node.js module will be local to that module.

[https://nodejs.org/api/globals.html#globals_global]

Name:
* cpt.ljnm'private-member,
* cpt.ljnm'member.private,
* cpt.ljnm'member.publicNo,
* cpt.ljnm'member.local,

Specific:
* any defined non-exporting member,
* __dirname-string-member,
* __filename-string-member,
* module-object-member,
* require-function-member,

ljnmmbr.__dirname-string

Description:
__dirname
String
The name of the directory that the currently executing script resides in.
Example: running node example.js from /Users/mjr
console.log(__dirname);
// /Users/mjr
__dirname isn't actually a global but rather local to each module.

[https://nodejs.org/api/globals.html#globals_dirname]

Name:
* cpt.ljn'__dirname,
* cpt.ljn'dirname,
* cpt.ljn__dirname,

ljnmmbr.__filename-string

Description:
__filename
String
The filename of the code being executed.
This is the resolved absolute path of this code file.
For a main program this is not necessarily the same filename used in the command line.
The value inside a module is the path to that module file.

Example: running node example.js from /Users/mjr
console.log(__filename);
// /Users/mjr/example.js

__filename isn't actually a global but rather local to each module.

[https://nodejs.org/api/globals.html#globals_filename]

Name:
* cpt.ljn'__filename,
* cpt.ljn'filename,
* cpt.ljnfilename,

ljnmmbr.module-object (ljnmobt)

Description:
The module Object
Object
In each module, the module free variable is a reference to the object representing the current module.
For convenience, module.exports is also accessible via the exports module-global.
module isn't actually a global but rather local to each module.

[https://nodejs.org/api/modules.html#modules_the_module_object]

Name:
* cpt.ljn'module-object,
* cpt.ljn'module,
* cpt.ljnmodule,
* cpt.ljn'module-o, {2016.07.24}
* cpt.ljnmobt, {2016.07.26}
===
The-name 'module' is ambiguous.
a) denotes the-module object, this concept.
b) denotes any module semantic-unit (ljnm).

Whole-chain:
* module-sut,
* most-whole-object (global),

Generic-chain:
* ?(Module.prototype) (module.__proto__ === Object.prototype //false),
* Object.prototype (module.__proto__.__proto__ === Object.prototype //true),
===
* module-sut-member,

ljnmobt'member

Member:
// ljn.6-2-2
> Object.getOwnPropertyNames(module).sort()
[ 'children', 'exports', 'filename', 'id', 'loaded', 'parent', 'paths' ]
> Object.getOwnPropertyNames(module.__proto__).sort()
[ '_compile', 'constructor', 'load', 'require' ]
> Object.getOwnPropertyNames(module.__proto__.__proto__).sort()
[ '__defineGetter__', '__defineSetter__', '__lookupGetter__', '__lookupSetter__', '__proto__', 'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'valueOf' ]

ljnmobtmbr.children-array

Description:
module.children
Array
The module objects required by this one.

[https://nodejs.org/api/modules.html#modules_module_children]

ljnmobtmbr.module.exports-object

Description:
module.exports holds the-public-member (exported) of a-module.
===
module.exports
Object
The module.exports object is created by the Module system.
Sometimes this is not acceptable; many want their module to be an instance of some class.
To do this, assign the desired export object to module.exports.
Note that assigning the desired object to exports will simply rebind the local exports variable, which is probably not what you want to do.
...
exports alias
The exports variable that is available within a module starts as a reference to module.exports.
As with any variable, if you assign a new value to it, it is no longer bound to the previous value.

[https://nodejs.org/docs/v6.3.1/api/modules.html#modules_module_exports]

ljnm'Exporting-MANY-MEMBERS

Description:
When we export many members, in fact we export ONE OBJECT with members these 'many' members.
To do this we use the-code:
module.exports.member = value;
or its alias
exports.member = value;

Name:
* cpt.ljn'exporting-many-members,
* cpt.ljnm'exporting-many-members,

ljnm'Exporting-SINGLE-MEMBER

Description:
To export a single semantic-unit we use the-code:
module.exports = value;
===
If you want the root of your module's export to be a function (such as a constructor) or if you want to export a complete object in one assignment instead of building it one property at a time, assign it to module.exports instead of exports.
[https://nodejs.org/api/modules.html#modules_modules]

Name:
* cpt.ljnm'exporting-single-member,
* cpt.ljnm'exporting-single-semantic-unit,

ljnmobtmbr.exports

Description:
For convenience, module.exports is also accessible via the exports module-global.
[http://openmymind.net/2012/2/3/Node-Require-and-Exports/]

Name:
* cpt.ljn'exports,
* cpt.ljnm'exports,
* cpt.ljnexports,

ljnmobtmbr.filename-string

Description:
module.filename
String
The fully resolved filename to the module.

[https://nodejs.org/api/modules.html#modules_module_filename]

Name:
* cpt.ljn'module.filename,

ljnmobtmbr.id-string

Description:
The identifier for the module. Typically this is the fully resolved filename.
[https://nodejs.org/api/modules.html#modules_module_id]

Name:
* cpt.ljn'module.id,
* cpt.ljnmodule.id,

ljnmobtmbr.loaded-boolean

Description:
Whether or not the module is done loading, or is in the process of loading.
[https://nodejs.org/api/modules.html#modules_module_loaded]

Name:
* cpt.ljn'module.loaded,
* cpt.ljnmodule.loaded,

ljnmobtmbr.parent-object

Description:
The module that first required this one.
[https://nodejs.org/api/modules.html#modules_module_parent]

Name:
* cpt.ljn'module.parent,
* cpt.ljnmodule.parent,

ljnmobtmbr.paths-object

Description:
> D:\ljn>node filStart
// module.paths
[ 'D:\\ljn\\node_modules' ]

Name:
* cpt.ljn'module.paths,
* cpt.ljnmodule.paths,

ljnmmbr.require-function

Description:
The-require-function IMPORTS modules into other modules.
When we import a-module, we import the-public-member[1] of the-module OR a-member of it[1] AND we execute the-code of the-module which could eg add a-global-member.

Name:
* cpt.ljn'require,
* cpt.ljnrequire,
* cpt.ljn'require-function,
* cpt.ljnrequire-function,
* cpt.ljnf.require,
* ljnrequire-cpt,

Whole-chain:
* module-semantic-unit,
* ljn-most-whole-object (global),

Generic-chain:
* Function.prototype,
* Object.prototype,

ljnrequire'Import-core-module

Description:
//just write the-module's name
const mFs = require('fs');
const mfEvents = require('events');

===
Without a leading '/' or './' to indicate a file, the module is either a "core module" or is loaded from a node_modules folder.
[http://nodejs.org/api/modules.html#modules_file_modules]

Name:
* cpt.ljn'import-core-module,
* cpt.ljnm'import-core-module,

ljnrequire'Import-member-of-module

Description:
const fDecoderString = require('string_decoder').StringDecoder;
var oDecoderString = new fDecoderString('utf8');

Name:
* cpt'ljn'import-part-of-module,
* cpt'ljnm'import-part-of-module,

ljnrequire'Import-from-relative-path

Description:
//from CURRENT directory
const mFoo = require('./filFoo');
//form SUBDIRECTORY
const mC = require ('./dirTest/filC');
//from PARENT directory
const mBar = require('../filBar');

Name:
* cpt'ljn'import-module-from-relative-path,
* cpt'ljnm'import-module-from-relative-path,

ljnrequire'Import-from-absolute-path

Description:
A module prefixed with '/' is an absolute path to the file.
For example, require('/home/marco/foo.js') will load the file at /home/marco/foo.js.

[http://nodejs.org/api/modules.html#modules_file_modules]

Name:
* cpt.ljn'import-module-from-absolute-path,
* cpt.ljnm'import-module-from-absolute-path,

ljnrequire'Import-by-searching

Description:
There are three ways in which you can require() files:
- using a relative path: foo = require('./lib/bar.js');
- using an absolute path: foo = require('/home/foo/lib/bar.js')
- using a search: foo = require('bar')
The first two are easy to understand.
In the third case, Node starts at the current directory, and adds ./node_modules/, and attempts to load the module from that location.
If the module is not found, then it moves to the parent directory and performs the same check, until the root of the filesystem is reached.

[http://book.mixu.net/node/single.html]

Name:
* cpt.ljn'import-by-searching,
* cpt.ljn'import-from-node_modules,
* cpt.ljnm'import-by-searching,
* cpt.ljnm'import-from-node_modules,

ljnrequire'Member

Description:
> Object.getOwnPropertyNames(require).sort()
[ 'cache', 'extensions', 'length', 'main', 'name', 'prototype', 'resolve' ]

===
> require
{ [Function: require]
resolve: [Function: resolve],
main: undefined,
extensions: { '.js': [Function], '.json': [Function], '.node': [Function] },
cache: {} }

ljnrequire.cache-object

Description:
Modules are cached in this object when they are required.
By deleting a key value from this object, the next require will reload the module.

[https://nodejs.org/api/globals.html#globals_require_cache]

Name:
* ljn'require.cache,
* ljnrequire.cache,

ljnrequire.main-object

Description:
Accessing the main module
When a file is run directly from Node.js, require.main is set to its module.
That means that you can determine whether a file has been run directly by testing
require.main === module
For a file foo.js, this will be true if run via node foo.js, but false if run by require('./foo').
Because module provides a filename property (normally equivalent to __filename), the entry point of the current application can be obtained by checking require.main.filename [from any module].

[https://nodejs.org/api/modules.html#modules_accessing_the_main_module]

Name:
* ljn'require.main,
* ljnrequire.main,

ljnrequire.resolve-function

Description:
Use the internal require() machinery to look up the location of a module, but rather than loading the module, just return the resolved filename.
[https://nodejs.org/api/globals.html#globals_require_resolve]

Name:
* ljnglobal.require.resolve,
* ljnrequire.resolve,

Code.ljn:
//on a-module with 'filB.js' on the-same directory
console.log(require.resolve('./filB'))
//D:\ljn\filB.js

ljnmmbr.VARIABLE

Description:
variables declared with the var keyword remain local to a module; those declared without it get attached to the global object.
[http://www.hacksparrow.com/global-variables-in-node-js.html]
===
Variables local to the module will be private, because the module is wrapped in a function by Node.js (see module wrapper).
[https://nodejs.org/api/modules.html]

Name:
* ljnm'variable,
* ljnm'name-value-pair,

Generic:
* ljn-module-member,
* ljn-name-value-pair,

ljnm'npm-tool (link)

ljnm'repository

Name:
* cpt.ljnm'repository,
* cpt.ljnm'storage,

Specific:
* public-repository,
* publicNo-repository,
===
* npmjs.org/
* node-modules.com/
* http://eirikb.github.io/nipster/

ljnm'npm-registry (npmjs.org)

Description:
Join the modular development revolution
Every month, more than 4 million developers use npm to find, share, and reuse code — and assemble it in powerful new ways.

[https://www.npmjs.com/]

Name:
* cpt.ljn'npm-registry,
* cpt.ljn'npmjs.org,
* cpt.ljnnpmjs.org,

npm-tool (link)

AddressWpg:
* https://www.npmjs.org/

Node Packaged Modules:
{2016.07}: 250,000 building blocks
{2014.02.16}: Total Packages: 59,377

ljnm'node_modules-directory

Description:
Without a leading '/' or './' to indicate a file, the module is either a "core module" or is loaded from a node_modules folder.
[https://nodejs.org/docs/v6.3.1/api/modules.html#modules_file_modules]
===
There are three ways in which you can require() files:
- using a relative path: foo = require('./lib/bar.js');
- using an absolute path: foo = require('/home/foo/lib/bar.js')
- using a search: foo = require('bar')
The first two are easy to understand.
In the third case, Node starts at the current directory, and adds ./node_modules/, and attempts to load the module from that location.
If the module is not found, then it moves to the parent directory and performs the same check, until the root of the filesystem is reached.

[http://book.mixu.net/node/single.html]
===
When you install a-module, with npm install 'module', it will-put it in node_modules-directory inside your current-directory.

Name:
* cpt.ljn'node_modules,
* cpt.ljn'node_modules-directory,
* cpt.ljn'node_modules-folder,
* ljn'node_modules-cpt,
* ljn'node_modules-directory-cpt,
* ljn'node_modules-folder-cpt,
* node_modules-cpt,
* node_modules-directory-cpt,
* node_modules-folder-cpt,

ljnm'node-modules.com

AddressWpg:
* http://node-modules.com/

ljnm'Resource

Name:
* cpt.ljnm'resource,
* cpt.ljn'module-resource,

AddressWpg:
* https://www.nczonline.net/blog/2016/04/es6-module-loading-more-complicated-than-you-think/: modules vs scripts,
* http://book.mixu.net/node/ch8.html,
* https://quickleft.com/blog/creating-and-publishing-a-node-js-module/,
* http://www.hacksparrow.com/how-to-write-node-js-modules.html,
* http://openmymind.net/2012/2/3/Node-Require-and-Exports/

ljnm'Converting-AMD-to-NodeJs-modules

Name:
* cpt.ljnm'converting-AMD-to-NodeJs-modules,
* cpt.ljn'Converting-AMD-to-NodeJs-modules,

AddressWpg:
* https://github.com/millermedeiros/nodefy,
* http://corner.squareup.com/2013/02/es6-module-transpiler.html,
* https://github.com/square/es6-module-transpiler,

ljnm'Stability-index (0 - 3)

Name:
* cpt.ljn'stability-index,
* cpt.ljnstability-index,
* cpt.ljnstability,

Description:
ljnstability0.Deprecated
This feature is known to be problematic, and changes are
planned. Do not rely on it. Use of the feature may cause warnings. Backwards
compatibility should not be expected.
ljnstability1.Experimental
This feature is subject to change, and is gated by a command line flag.
It may change or be removed in future versions.
ljnstability2.Stable
The API has proven satisfactory.
Compatibility with the npm ecosystem
is a high priority, and will not be broken unless absolutely necessary.
ljnstability3.Locked
Only fixes related to security, performance, or bug fixes will be accepted.
Please do not suggest API changes in this area; they will be refused.
[https://nodejs.org/api/documentation.html#documentation_stability_index]
===
The stability indices are as follows:

Stability: 0 - Deprecated
This feature is known to be problematic, and changes are
planned. Do not rely on it. Use of the feature may cause warnings. Backwards
compatibility should not be expected.

Stability: 1 - Experimental
This feature was introduced recently, and may change
or be removed in future versions. Please try it out and provide feedback.
If it addresses a use-case that is important to you, tell the node core team.

Stability: 2 - Unstable
The API is in the process of settling, but has not yet had
sufficient real-world testing to be considered stable.
Backwards-compatibility
will be maintained if reasonable.

Stability: 3 - Stable
The API has proven satisfactory, but cleanup in the underlying
code may cause minor changes. Backwards-compatibility is guaranteed.

Stability: 4 - API Frozen
This API has been tested extensively in production and is
unlikely to ever have to change.

Stability: 5 - Locked
Unless serious bugs are found, this code will not ever
change. Please do not suggest changes in this area; they will be refused.

[https://nodejs.org/docs/latest-v0.10.x/doc/api/documentation.html#documentation_stability_index]

ljnm'Wraper

Description:
Modules actually are (implemented as) self-executing-functions that RETURN the-semantic-unit which contains the-public-members of the-module.
[HmnSynagonism.2016-07-25]
===
The module wrapper
Before a module's code is executed, Node.js will wrap it with a function wrapper that looks like the following:
(function (exports, require, module, __filename, __dirname) {
// Your module code actually lives in here
});

By doing this, Node.js achieves a few things:
- It keeps top-level variables (defined with var, const or let) scoped to the module rather than the global object.
- It helps to provide some global-looking variables that are actually specific to the module, such as:
-- The module and exports objects that the implementor can use to export values from the module.
-- The convenience variables __filename and __dirname, containing the module's absolute filename and directory path.

[https://nodejs.org/api/modules.html#modules_the_module_wrapper]

Name:
* cpt.ljnm'wrapper,
* cpt.ljn'module-wrapper,

SPECIFIC

Name:
* cpt.ljnm.specific,
* ljnm.specific-cpt,
* mdlNode.specific-cpt,

Specific:
* core-module,
* coreNo-module,
===
* main-module,
* mainNo-module,
===
* directory-module,
* file-module,
===
There are three types of modules in Node.js:
internal modules (parts of Node API)
3rd party modules written in javascript
3rd party modules with C/C++ addons

[https://github.com/rogerwang/node-webkit/wiki/Using-Node-modules]

ljnm.CORE

Description:
Core Modules
Node has several modules compiled into the binary.
These modules are described in greater detail elsewhere in this documentation.

The core modules are defined in node's source in the lib/ folder.

Core modules are always preferentially loaded if their identifier is passed to require().
For instance, require('http') will always return the built in HTTP module, even if there is a file by that name.

[https://nodejs.org/docs/v6.3.1/api/modules.html#modules_core_modules]

Name:
* cpt.ljn'core-module,
* cpt.ljn'native-module,
* cpt.ljnm.builtIn,
* cpt.ljnm.customNo,
* cpt.ljnm.internal,
* cpt.ljnm.native,

Specific:
* ljnm.assert,
* ljnm.child_process,
* ljnm.cluster,
* ljnm.crypto,
* ljnm.dns,
* ljnm.events,
* ljnm.fs,
* ljnm.http,
* ljnm.https,
* ljnm.net,
* ljnm.os,
* ljnm.path,
* ljnm.readline,
* ljnm.repl,
* ljnm.stream,
* ljnm.string_decoder,
* ljnm.tls,
* ljnm.tty,
* ljnm.url,
* ljnm.util,
* ljnm.vm,
* ljnm.zlib,
===
// ljn.6-3-1
> repl._builtinLibs
[ 'assert', 'buffer', 'child_process', 'cluster', 'crypto', 'dgram', 'dns', 'domain', 'events', 'fs', 'http', 'https', 'net', 'os', 'path', 'punycode', 'querystring', 'readline', 'repl', 'stream', 'string_decoder', 'tls', 'tty', 'url', 'util', 'v8', 'vm', 'zlib' ]

ljnm.core.assert-function (core 3.locked)

Description:
The assert module provides a simple set of assertion tests that can be used to test invariants.
The module is intended for internal use by Node.js, but can be used in application code via require('assert').
However, assert is not a testing framework, and is not intended to be used as a general purpose assertion library.
The API for the assert module is Locked.
This means that there will be no additions or changes to any of the methods implemented and exposed by the module.

[https://nodejs.org/docs/v6.3.1/api/assert.html#assert_assert]

Name:
* cpt.ljn'assert-module,
* cpt.ljn'assert,
* cpt.ljnassert,
* cpt.ljnm.assert,
* cpt.ljnmfAssert,

Whole-chain:
* module-instance,
* most-whole-object (global),

Generic-chain:
* Function.prototype (mfAssert.__proto__ === Function.prototype //true)
* Object.prototype,

Member:
// ljn.6-3-1
// Object.getOwnPropertyNames(mfAssert).sort()
[ 'AssertionError', 'deepEqual', 'deepStrictEqual', 'doesNotThrow', 'equal', 'fail', 'ifError', 'length', 'name', 'notDeepEqual', 'notDeepStrictEqual', 'notEqual', 'notStrictEqual', 'ok', 'prototype', 'strictEqual', 'throws' ]

ljnm.core.events-function (core 2.stable)

Description:
Much of the Node.js core API is built around an idiomatic asynchronous event-driven architecture in which certain kinds of objects (called "emitters") periodically emit named events that cause Function objects ("listeners") to be called.

For instance: a net.Server object emits an event each time a peer connects to it; a fs.ReadStream emits an event when the file is opened; a stream emits an event whenever data is available to be read.

All objects that emit events are instances of the EventEmitter class.
These objects expose an eventEmitter.on() function that allows one or more functions to be attached to named events emitted by the object.
Typically, event names are camel-cased strings but any valid JavaScript property key can be used.

When the EventEmitter object emits an event, all of the functions attached to that specific event are called synchronously.
Any values returned by the called listeners are ignored and will be discarded.

[https://nodejs.org/docs/v6.3.1/api/events.html#events_events]

Name:
* cpt.ljn'events-module,
* cpt.ljn'events,
* cpt.ljnm.events,
* cpt.ljnmfEvents,
* cpt.ljn'events-function,
* cpt.ljnevents,

Whole-chain:
* module-instance,
* most-whole-object (global),

Generic-chain:
* Function.prototype, (mfEvents.__proto__ === Function.prototype //true)
* Object.prototype, (mfEvents.__proto__.__proto__ === Object.prototype //true)

mfEvents'member

mfEvents'Member:
// ljn.6-3-1
// Object.getOwnPropertyNames(mfEvents).sort()
[ 'EventEmitter',
'defaultMaxListeners',
'init',
'length',
'listenerCount',
'name',
'prototype',
'usingDomains' ]
===
// mfEvents
{ [Function: EventEmitter]
EventEmitter: [Circular],
usingDomains: true,
defaultMaxListeners: [Getter/Setter],
init: [Function],
listenerCount: [Function] }

mfEvents.EventEmitter-function

Description:
events.EventEmitter === events
[HmnSynagonism.2016-07-02]
===
To access the EventEmitter class, require('events').EventEmitter.

When an EventEmitter instance experiences an error, the typical action is to emit an 'error' event.
Error events are treated as a special case in node.
If there is no listener for it, then the default action is to print a stack trace and exit the program.

All EventEmitters emit the event 'newListener' when new listeners are added and 'removeListener' when a listener is removed.

[https://nodejs.org/docs/v0.12.0/api/events.html#events_class_events_eventemitter]

Name:
* cpt.ljnmfEvents'EventEmitter,
* cpt.ljn'EventEmitter,
* cpt.ljnEventEmitter,

mfEvents.prototype-object

Member:
// ljn.6-3-1
// Object.getOwnPropertyNames(mfEvents.prototype).sort()
[ '_events', '_maxListeners', 'addListener', 'constructor', 'domain', 'emit', 'eventNames', 'getMaxListeners', 'listenerCount', 'listeners', 'on', 'once', 'prependListener', 'prependOnceListener', 'removeAllListeners', 'removeListener', 'setMaxListeners' ]

Name:
* cpt.ljn'events.prototype,
* cpt.ljn'mfEvents.prototype,
* cpt.ljnmfEvents.prototype,

mfEvents'listener-function

Description:
Functions can then be attached to objects, to be executed when an event is emitted.
These functions are called listeners.
Inside a listener function, this refers to the EventEmitter that the listener was attached to.

[https://nodejs.org/docs/v0.12.0/api/events.html#events_events]

Name:
* cpt.ljn'event-listener,

ljnm.core.stream-function (core 2.stable)

Description:
A stream is an abstract interface for working with streaming data in Node.js.
The stream module provides a base API that makes it easy to build objects that implement the stream interface.

There are many stream objects provided by Node.js.
For instance, a request to an HTTP server and process.stdout are both stream instances.

Streams can be readable, writable, or both.
All streams are instances of EventEmitter.

The stream module can be accessed using:
const stream = require('stream');

While it is important for all Node.js users to understand how streams works, the stream module itself is most useful for developer's that are creating new types of stream instances.
Developer's who are primarily consuming stream objects will rarely (if ever) have need to use the stream module directly.

[https://nodejs.org/api/stream.html#stream_stream]

Name:
* cpt.ljn'stream-module,
* cpt.ljn'stream-functin,
* cpt.ljnm.stream,
* cpt.ljnmfStream,
* cpt.ljn'mfStream,
* cpt.ljn'stream,
* cpt.ljnstream,

Whole-chain:
* module-instance,
* most-whole-object (global),

Generic-chain:
* Function.prototype, (mfStream.__proto__ === Function.prototype //true)
* Object.prototype (mfStream.__proto__.__proto__ === Object.prototype //true)

Member:
// ljn.6-2-2
// Object.getOwnPropertyNames(mfStream).sort()
[ 'Duplex', 'PassThrough', 'Readable', 'Stream', 'Transform', 'Writable', 'length', 'name', 'prototype', 'super_' ]
===
> stream
{ [Function: Stream]
super_:
{ [Function: EventEmitter]
EventEmitter: [Circular],
usingDomains: true,
defaultMaxListeners: [Getter/Setter],
init: [Function],
listenerCount: [Function] },
Readable:
{ [Function: Readable]
ReadableState: [Function: ReadableState],
super_: [Circular],
_fromList: [Function: fromList] },
Writable: { [Function: Writable] WritableState: [Function: WritableState], super_: [Circular] },
Duplex:
{ [Function: Duplex]
super_:
{ [Function: Readable]
ReadableState: [Function: ReadableState],
super_: [Circular],
_fromList: [Function: fromList] } },
Transform: { [Function: Transform] super_: { [Function: Duplex] super_: [Object] } },
PassThrough: { [Function: PassThrough] super_: { [Function: Transform] super_: [Object] } },
Stream: [Circular] }

mfStream-object:
The-objects of mfStream are instances of mfEvents.prototype.
var oStream = new mfStream();
oStream.__proto__ === mfStream.prototype //true
oStream.__proto__.__proto__ === mfEvents.prototype //true
oStream.__proto__.__proto__.__proto__ === Object.prototype //true

===
All streams are instances of EventEmitter.
[https://nodejs.org/api/stream.html#stream_stream]

ljnm.core.buffer-object (core 2.stable)

Description:
The-buffer-module contains the-Buffer-function, which is and global-member.
===
The Buffer class is a global within Node.js, making it unlikely that one would need to ever use require('buffer').Buffer.
[https://nodejs.org/docs/v6.3.1/api/buffer.html#buffer_buffer]

Name:
* cpt.ljn'buffer-module,
* cpt.ljn'buffer-object,
* cpt.ljnm.buffer,
* cpt.ljnmBuffer,
* cpt.ljn'mBuffer,
* cpt.ljn'buffer,
* cpt.ljnbuffer,

Whole-chain:
* module-instance,
* most-whole-object (global),

Generic-chain:
* Object.prototype, (mBuffer.__proto__ === Object.prototype)

Member:
// ljn.6-3-1
// Object.getOwnPropertyNames(mBuffer).sort()
[ 'Buffer', 'INSPECT_MAX_BYTES', 'SlowBuffer', 'kMaxLength' ]

ljnm.core.child_process-object (core 2=stable)

Description:
Node provides a tri-directional popen(3) facility through the child_process module.

It is possible to stream data through a child's stdin, stdout, and stderr in a fully non-blocking way. (Note that some programs use line-buffered I/O internally.
That doesn't affect node.js but it means data you send to the child process is not immediately consumed.)

To create a child process use require('child_process').spawn() or require('child_process').fork().
The semantics of each are slightly different, and explained below.

[https://nodejs.org/docs/v0.12.0/api/child_process.html#child_process_child_process]

Name:
* cpt.ljn'child_process-module,
* cpt.ljn'child_process,
* cpt.ljnchild_process,
* cpt.ljnm.child_process,
* cpt.ljnmChild_process,

Whole-chain:
* module-instance,
* most-whole-object (global),

Generic-chain:
* Object.prototype, (mChild_process.__proto__ === Object.prototype //true)

ljnm.core.cluster-object (core 2=stable)

Description:
A single instance of Node.js runs in a single thread.
To take advantage of multi-core systems the user will sometimes want to launch a cluster of Node.js processes to handle the load.

[https://nodejs.org/docs/v6.3.1/api/cluster.html#cluster_cluster]

Name:
* cpt.ljn'cluster-module,
* cpt.ljn'mCluster,
* cpt.ljnmCluster,
* cpt.ljncluster,
* cpt.ljn'cluster,
* cpt.ljn'cluster-object,
* cluster-module-cpt,

Whole-chain:
* module-instance,
* most-whole-object (global),

Generic-chain:
* events.prototype (mCluster.__proto__ === mfEvents.prototype //true)
* Object.prototype (mCluster.__proto__.__proto__ === Object.prototype //true)

ljnm.core.crypto-object (core 2.stable)

Description:
The crypto module provides cryptographic functionality that includes a set of wrappers for OpenSSL's hash, HMAC, cipher, decipher, sign and verify functions.
Use require('crypto') to access this module.

[https://nodejs.org/api/crypto.html#crypto_crypto]

Name:
* cpt.ljn'crypto,
* cpt.ljncrypto,
* cpt.ljnm.crypto,
* cpt.ljnmCrypto,
* cpt.ljn'crypto-object,
* cpt.ljn'crypto-module,

Whole-chain:
* module-instance,
* most-whole-object (global),

Generic-chain:
* Object.prototype (mCrypto.__proto__ === Object.prototype //true)

Member:
// ljn.6-3-1
// Object.getOwnPropertyNames(mCrypto).sort()
[ 'Certificate', 'Cipher', 'Cipheriv', 'Credentials', 'DEFAULT_ENCODING', 'Decipher', 'Decipheriv', 'DiffieHellman', 'DiffieHellmanGroup', 'Hash', 'Hmac', 'Sign', 'Verify', '_toBuf', 'constants', 'createCipher', 'createCipheriv', 'createCredentials', 'createDecipher', 'createDecipheriv', 'createDiffieHellman', 'createDiffieHellmanGroup', 'createECDH', 'createHash', 'createHmac', 'createSign', 'createVerify', 'fips', 'getCiphers', 'getCurves', 'getDiffieHellman', 'getHashes', 'pbkdf2', 'pbkdf2Sync', 'privateDecrypt', 'privateEncrypt', 'prng', 'pseudoRandomBytes', 'publicDecrypt', 'publicEncrypt', 'randomBytes', 'rng', 'setEngine' ]

ljnm.core.dns-object (core 2.stable)

Description:
The dns module contains functions belonging to two different categories:
1) Functions that use the underlying operating system facilities to perform name resolution, and that do not necessarily perform any network communication. This category contains only one function: dns.lookup().
Developers looking to perform name resolution in the same way that other applications on the same operating system behave should use dns.lookup().
...
2) Functions that connect to an actual DNS server to perform name resolution, and that always use the network to perform DNS queries.
This category contains all functions in the dns module except dns.lookup().
These functions do not use the same set of configuration files used by dns.lookup() (e.g. /etc/hosts).
These functions should be used by developers who do not want to use the underlying operating system's facilities for name resolution, and instead want to always perform DNS queries.

[https://nodejs.org/api/dns.html#dns_dns]

Name:
* cpt.ljn'dns,
* cpt.ljndns,
* cpt.ljnm.dns,
* cpt.ljnmDns,
* cpt.ljn'dns-object,
* cpt.ljn'dns-module,

Whole-chain:
* module-instance,
* most-whole-object (global),

Generic-chain:
* Object.prototype (mDns.__proto__ === Object.prototype //true)

ljndns'Member:
// ljn.6-2-2
// Object.getOwnPropertyNames(mDns).sort()
[ 'ADDRCONFIG', 'ADDRGETNETWORKPARAMS', 'BADFAMILY', 'BADFLAGS', 'BADHINTS', 'BADNAME', 'BADQUERY', 'BADRESP', 'BADSTR', 'CANCELLED', 'CONNREFUSED', 'DESTRUCTION', 'EOF', 'FILE', 'FORMERR', 'LOADIPHLPAPI', 'NODATA', 'NOMEM', 'NONAME', 'NOTFOUND', 'NOTIMP', 'NOTINITIALIZED', 'REFUSED', 'SERVFAIL', 'TIMEOUT', 'V4MAPPED', 'getServers', 'lookup', 'lookupService', 'resolve', 'resolve4', 'resolve6', 'resolveCname', 'resolveMx', 'resolveNaptr', 'resolveNs', 'resolvePtr', 'resolveSoa', 'resolveSrv', 'resolveTxt', 'reverse', 'setServers' ]
===
// mDns
{ lookup: [Function: lookup],
lookupService: [Function],
resolve4: [Function: query],
resolve6: [Function: query],
resolveCname: [Function: query],
resolveMx: [Function: query],
resolveNs: [Function: query],
resolveTxt: [Function: query],
resolveSrv: [Function: query],
resolvePtr: [Function: query],
resolveNaptr: [Function: query],
resolveSoa: [Function: query],
reverse: [Function: query],
resolve: [Function],
getServers: [Function],
setServers: [Function],
ADDRCONFIG: 1024,
V4MAPPED: 2048,
NODATA: 'ENODATA',
FORMERR: 'EFORMERR',
SERVFAIL: 'ESERVFAIL',
NOTFOUND: 'ENOTFOUND',
NOTIMP: 'ENOTIMP',
REFUSED: 'EREFUSED',
BADQUERY: 'EBADQUERY',
BADNAME: 'EBADNAME',
BADFAMILY: 'EBADFAMILY',
BADRESP: 'EBADRESP',
CONNREFUSED: 'ECONNREFUSED',
TIMEOUT: 'ETIMEOUT',
EOF: 'EOF',
FILE: 'EFILE',
NOMEM: 'ENOMEM',
DESTRUCTION: 'EDESTRUCTION',
BADSTR: 'EBADSTR',
BADFLAGS: 'EBADFLAGS',
NONAME: 'ENONAME',
BADHINTS: 'EBADHINTS',
NOTINITIALIZED: 'ENOTINITIALIZED',
LOADIPHLPAPI: 'ELOADIPHLPAPI',
ADDRGETNETWORKPARAMS: 'EADDRGETNETWORKPARAMS',
CANCELLED: 'ECANCELLED' }

ljnm.core.fs-object (core 3=stable)

Description:
File I/O is provided by simple wrappers around standard POSIX functions.
To use this module do require('fs').
All the methods have asynchronous and synchronous forms.

The asynchronous form always take a completion callback as its last argument.
The arguments passed to the completion callback depend on the method, but the first argument is always reserved for an exception.
If the operation was completed successfully, then the first argument will be null or undefined.

When using the synchronous form any exceptions are immediately thrown.
You can use try/catch to handle exceptions or allow them to bubble up.

[http://nodejs.org/api/all.html#all_file_system]

Name:
* cpt.ljn'file-system-module,
* cpt.ljn'fs-module,
* cpt.ljn'fs-object,
* cpt.ljnm.fs,
* cpt.ljnmFs,
* cpt.ljnfs,

Whole-chain:
* module-instance,
* most-whole-object (global),

Generic-chain:
* Object.prototype, (mFs.__proto__ === Object.prototype //true)

AddressWpg:
* http://nodejs.org/api/all.html#all_file_system,

mFs'Member:
// ljn.6-3-1
// Object.getOwnPropertyNames(mFs).sort()
[ 'F_OK', 'FileWriteStream', 'ReadStream', 'SyncWriteStream', 'WriteStream', '_stringToFlags', 'access', 'appendFile', 'chmod', 'chown', 'close', 'constants', 'createWriteStream', 'existsSync', 'fchmodSync', 'fchownSync', 'fdatasync', 'fdatasyncSync', 'fstat', 'fstatSync', 'fsync', 'fsyncSync', 'ftruncate', 'ftruncateSync', 'futimes', 'futimesSync', 'link', 'linkSync', 'lstat', 'lstatSync', 'mkdir', 'mkdirSync', 'mkdtemp', 'mkdtempSync', 'open', 'openSync', 'read', 'readFile', 'readFileSync', 'readSync', 'readdir', 'readdirSync', 'readlink', 'readlinkSync', 'realpath', 'realpathSync', 'rename', 'renameSync', 'rmdir', 'rmdirSync', 'stat', 'statSync', 'symlink', 'symlinkSync', 'truncate', 'truncateSync', 'unlink', 'unlinkSync', 'unwatchFile', 'utimes', 'utimesSync', 'watch', 'watchFile', 'write', 'writeFile', 'writeFileSync', 'writeSync' ]
===
mFs.ReadStream_Class
mFs.Stats_Class
mFs.WriteStream_Class
mFs.appendFile(filename, data, [options], callback)
mFs.appendFileSync(filename, data, [options])
mFs.chmod(path, mode, callback)
mFs.chmodSync(path, mode)
mFs.chown(path, uid, gid, callback)
mFs.chownSync(path, uid, gid)
mFs.close(fd, callback)
mFs.closeSync(fd)
mFs.createReadStream(path, [options])
mFs.createWriteStream(path, [options])
mFs.exists(path, callback)
mFs.existsSync(path)
mFs.fchmod(fd, mode, callback)
mFs.fchmodSync(fd, mode)
mFs.fchown(fd, uid, gid, callback)
mFs.fchownSync(fd, uid, gid)
mFs.fstat(fd, callback)
mFs.fstatSync(fd)
mFs.fsync(fd, callback)
mFs.fsyncSync(fd)
mFs.ftruncate(fd, len, callback)
mFs.ftruncateSync(fd, len)
mFs.futimes(fd, atime, mtime, callback)
mFs.futimesSync(fd, atime, mtime)
mFs.lchmod(path, mode, callback)
mFs.lchmodSync(path, mode)
mFs.lchown(path, uid, gid, callback)
mFs.lchownSync(path, uid, gid)
mFs.link(srcpath, dstpath, callback)
mFs.linkSync(srcpath, dstpath)
mFs.lstat(path, callback)
mFs.lstatSync(path)
mFs.mkdir(path, [mode], callback)
mFs.mkdirSync(path, [mode])
mFs.open(path, flags, [mode], callback)
mFs.openSync(path, flags, [mode])
mFs.read(fd, buffer, offset, length, position, callback)
mFs.readFile(filename, [options], callback)
mFs.readFileSync(filename, [options])
mFs.readSync(fd, buffer, offset, length, position)
mFs.readdir(path, callback)
mFs.readdirSync(path)
mFs.readlink(path, callback)
mFs.readlinkSync(path)
mFs.realpath(path, [cache], callback)
mFs.realpathSync(path, [cache])
mFs.rename(oldPath, newPath, callback)
mFs.renameSync(oldPath, newPath)
mFs.rmdir(path, callback)
mFs.rmdirSync(path)
mFs.stat(path, callback)
mFs.statSync(path)
mFs.symlink(srcpath, dstpath, [type], callback)
mFs.symlinkSync(srcpath, dstpath, [type])
mFs.truncate(path, len, callback)
mFs.truncateSync(path, len)
mFs.unlink(path, callback)
mFs.unlinkSync(path)
mFs.unwatchFile(filename, [listener])
mFs.utimes(path, atime, mtime, callback)
mFs.utimesSync(path, atime, mtime)
mFs.watch(filename, [options], [listener])
mFs.watchFile(filename, [options], listener)
mFs.write(fd, buffer, offset, length, position, callback)
mFs.writeFile(filename, data, [options], callback)
mFs.writeFileSync(filename, data, [options])
mFs.writeSync(fd, buffer, offset, length, position)

ljnm.core.http-object (core 2.stable)

Description:
To use the HTTP server and client one must require('http').

The HTTP interfaces in Node are designed to support many features of the protocol which have been traditionally difficult to use.
In particular, large, possibly chunk-encoded, messages.
The interface is careful to never buffer entire requests or responses--the user is able to stream data.

HTTP message headers are represented by an object like this:
{ 'content-length': '123',
'content-type': 'text/plain',
'connection': 'keep-alive',
'host': 'mysite.com',
'accept': '*/*' }
Keys are lowercased.
Values are not modified.

In order to support the full spectrum of possible HTTP applications, Node's HTTP API is very low-level.
It deals with stream handling and message parsing only.
It parses a message into headers and body but it does not parse the actual headers or the body...

[https://nodejs.org/docs/v6.3.1/api/http.html#http_http]

Name:
* cpt.ljn'http-module,
* cpt.ljn'http-object,
* cpt.ljnm.http,
* cpt.ljnmHttp,
* cpt.ljnhttp,

Whole-chain:
* module-instance,
* most-whole-object (global),

Generic-chain:
* Object.prototype, (mHttp.__proto__ === Object.prototype //true)

mHttp'member

mHttp'Member:
// ljn.6-2-2
// Object.getOwnPropertyNames(mHttp).sort()
[ 'Agent', 'Client', 'ClientRequest', 'IncomingMessage', 'METHODS', 'OutgoingMessage', 'STATUS_CODES', 'Server', 'ServerResponse', '_connectionListener', 'createClient', 'createServer', 'get', 'globalAgent', 'request' ]

mHttp.Agent-function

Description:
Agent:
{ [Function: Agent]
super_:
{ [Function: EventEmitter]
EventEmitter: [Circular],
usingDomains: true,
defaultMaxListeners: [Getter/Setter],
init: [Function],
listenerCount: [Function] },
defaultMaxSockets: Infinity },

mHttp.Client Function: deprecated

Description:
Client: [Function: deprecated],

mHttp.ClientRequest-function

Description:
ClientRequest: { [Function: ClientRequest] super_: { [Function: OutgoingMessage] super_: [Object] } },

mHttp.IncomingMessage-function

Description:
IncomingMessage:
{ [Function: IncomingMessage]
super_:
{ [Function: Readable]
ReadableState: [Function: ReadableState],
super_: [Object],
_fromList: [Function: fromList] } },

mHttp.METHODS-array

Description:
METHODS:
[ 'ACL', 'BIND', 'CHECKOUT', 'CONNECT', 'COPY', 'DELETE', 'GET', 'HEAD', 'LINK', 'LOCK', 'M-SEARCH', 'MERGE', 'MKACTIVITY', 'MKCALENDAR', 'MKCOL', 'MOVE', 'NOTIFY', 'OPTIONS', 'PATCH', 'POST', 'PROPFIND', 'PROPPATCH', 'PURGE', 'PUT', 'REBIND', 'REPORT', 'SEARCH', 'SUBSCRIBE', 'TRACE', 'UNBIND', 'UNLINK', 'UNLOCK', 'UNSUBSCRIBE' ],

mHttp.OutgoingMessage-function

Description:
OutgoingMessage:
{ [Function: OutgoingMessage]
super_:
{ [Function: Stream]
super_: [Object],
Readable: [Object],
Writable: [Object],
Duplex: [Object],
Transform: [Object],
PassThrough: [Object],
Stream: [Circular] } },

mHttp.STATUS_CODES-object

Description:
STATUS_CODES:
{ '100': 'Continue',
'101': 'Switching Protocols',
'102': 'Processing',
'200': 'OK',
'201': 'Created',
'202': 'Accepted',
'203': 'Non-Authoritative Information',
'204': 'No Content',
'205': 'Reset Content',
'206': 'Partial Content',
'207': 'Multi-Status',
'208': 'Already Reported',
'226': 'IM Used',
'300': 'Multiple Choices',
'301': 'Moved Permanently',
'302': 'Found',
'303': 'See Other',
'304': 'Not Modified',
'305': 'Use Proxy',
'307': 'Temporary Redirect',
'308': 'Permanent Redirect',
'400': 'Bad Request',
'401': 'Unauthorized',
'402': 'Payment Required',
'403': 'Forbidden',
'404': 'Not Found',
'405': 'Method Not Allowed',
'406': 'Not Acceptable',
'407': 'Proxy Authentication Required',
'408': 'Request Timeout',
'409': 'Conflict',
'410': 'Gone',
'411': 'Length Required',
'412': 'Precondition Failed',
'413': 'Payload Too Large',
'414': 'URI Too Long',
'415': 'Unsupported Media Type',
'416': 'Range Not Satisfiable',
'417': 'Expectation Failed',
'418': 'I\'m a teapot',
'421': 'Misdirected Request',
'422': 'Unprocessable Entity',
'423': 'Locked',
'424': 'Failed Dependency',
'425': 'Unordered Collection',
'426': 'Upgrade Required',
'428': 'Precondition Required',
'429': 'Too Many Requests',
'431': 'Request Header Fields Too Large',
'451': 'Unavailable For Legal Reasons',
'500': 'Internal Server Error',
'501': 'Not Implemented',
'502': 'Bad Gateway',
'503': 'Service Unavailable',
'504': 'Gateway Timeout',
'505': 'HTTP Version Not Supported',
'506': 'Variant Also Negotiates',
'507': 'Insufficient Storage',
'508': 'Loop Detected',
'509': 'Bandwidth Limit Exceeded',
'510': 'Not Extended',
'511': 'Network Authentication Required' },

mHttp.Server-function

Description:
Server: { [Function: Server] super_: { [Function: Server] super_: [Object] } },

mHttp.ServerResponse-function

Description:
ServerResponse: { [Function: ServerResponse] super_: { [Function: OutgoingMessage] super_: [Object] } },

mHttp._connectionListener-function

Description:
_connectionListener: [Function: connectionListener],

mHttp.createClient Function: deprecated

Description:
createClient: [Function: deprecated]

mHttp.createServer-function

Description:
createServer: [Function],

mHttp.get-function

Description:
get: [Function],

mHttp.globalAgent-object

Description:
globalAgent:
Agent {
domain:
Domain {
domain: null,
_events: [Object],
_eventsCount: 1,
_maxListeners: undefined,
members: [] },
_events: { free: [Function] },
_eventsCount: 1,
_maxListeners: undefined,
defaultPort: 80,
protocol: 'http:',
options: { path: null },
requests: {},
sockets: {},
freeSockets: {},
keepAliveMsecs: 1000,
keepAlive: false,
maxSockets: Infinity,
maxFreeSockets: 256 },

mHttp.request-function

Description:
request: [Function],

ljnm.core.https-object (core 2.stable)

Description:
HTTPS is the HTTP protocol over TLS/SSL.
In Node.js this is implemented as a separate module.

[https://nodejs.org/docs/v6.3.1/api/https.html#https_https]

Name:
* cpt.ljn'https-module,
* cpt.ljn'https-object,
* cpt.ljnm.https,
* cpt.ljnmHttps,
* cpt.ljnhttps,

Whole-chain:
* module-instance,
* most-whole-object (global),

Generic-chain:
* Object.prototype, (mHttps.__proto__ === Object.prototype //true)

mHttps'Member:
// ljn.6-2-2
// Object.getOwnPropertyNames(mHttps).sort()
[ 'Agent',
'Server',
'createServer',
'get',
'globalAgent',
'request' ]
===
// mHttps
{ Server: { [Function: Server] super_: { [Function: Server] super_: [Object] } },
createServer: [Function],
globalAgent:
Agent {
domain:
Domain {
domain: null,
_events: [Object],
_eventsCount: 1,
_maxListeners: undefined,
members: [] },
_events: { free: [Function] },
_eventsCount: 1,
_maxListeners: undefined,
defaultPort: 443,
protocol: 'https:',
options: { path: null },
requests: {},
sockets: {},
freeSockets: {},
keepAliveMsecs: 1000,
keepAlive: false,
maxSockets: Infinity,
maxFreeSockets: 256,
maxCachedSessions: 100,
_sessionCache: { map: {}, list: [] } },
Agent:
{ [Function: Agent]
super_: { [Function: Agent] super_: [Object], defaultMaxSockets: Infinity } },
request: [Function],
get: [Function] }

ljnm.core.net-object (core 2.stable)

Description:
The net module provides you with an asynchronous network wrapper.
It contains functions for creating both servers and clients (called streams).
You can include this module with require('net');.

[https://nodejs.org/docs/v6.3.1/api/net.html#net_net]

Name:
* cpt.ljn'net-module,
* cpt.ljn'net-object,
* cpt.ljnm.net,
* cpt.ljnmNet,
* cpt.ljn'net,
* cpt.ljnnet,

Whole-chain:
* module-instance,
* most-whole-object (global),

Generic-chain:
* Object.prototype, (mNet.__proto__ === Object.prototype //true)

ljnnet'Member:
// ljn.6-2-2
// Object.getOwnPropertyNames(mNet).sort()
[ 'Server', 'Socket', 'Stream', '_createServerHandle', '_normalizeConnectArgs', '_setSimultaneousAccepts', 'connect', 'createConnection', 'createServer', 'isIP', 'isIPv4', 'isIPv6' ]
===
// mNet
{ createServer: [Function],
createConnection: [Function],
connect: [Function],
_normalizeConnectArgs: [Function: normalizeConnectArgs],
Socket: { [Function: Socket] super_: { [Function: Duplex] super_: [Object] } },
Stream: { [Function: Socket] super_: { [Function: Duplex] super_: [Object] } },
Server:
{ [Function: Server]
super_:
{ [Function: EventEmitter]
EventEmitter: [Circular],
usingDomains: true,
defaultMaxListeners: [Getter/Setter],
init: [Function],
listenerCount: [Function] } },
_createServerHandle: [Function: createServerHandle],
isIP: [Function: isIP],
isIPv4: [Function],
isIPv6: [Function],
_setSimultaneousAccepts: [Function] }

ljnm.core.os-object (core 2.stable)

Description:
The os module provides a number of operating system-related utility methods.
It can be accessed using:
const os = require('os');

[https://nodejs.org/docs/v6.3.1/api/os.html#os_os]

Whole-chain:
* module-instance,
* most-whole-object (global),

Generic-chain:
* Object.prototype, (mOs.__proto__ === Object.prototype //true)

ljnos'Member:
// ljn.6-2-2
// Object.getOwnPropertyNames(mOs).sort()
[ 'EOL', 'arch', 'cpus', 'endianness', 'freemem', 'getNetworkInterfaces', 'homedir', 'hostname', 'loadavg', 'networkInterfaces', 'platform', 'release', 'tmpDir', 'tmpdir', 'totalmem', 'type', 'uptime', 'userInfo' ]
===
// mOs
{ hostname: [Function: getHostname],
loadavg: [Function: getLoadAvg],
uptime: [Function: getUptime],
freemem: [Function: getFreeMem],
totalmem: [Function: getTotalMem],
cpus: [Function: getCPUs],
type: [Function: getOSType],
release: [Function: getOSRelease],
networkInterfaces: [Function: getInterfaceAddresses],
homedir: [Function: getHomeDirectory],
userInfo: [Function: getUserInfo],
arch: [Function],
platform: [Function],
tmpdir: [Function],
tmpDir: [Function],
getNetworkInterfaces: [Function: deprecated],
EOL: '\r\n',
endianness: [Function] }

ljnm.core.path-object (core 2.stable)

Description:
The path module provides utilities for working with file and directory paths.
It can be accessed using:
const path = require('path');

[https://nodejs.org/docs/v6.3.1/api/path.html#path_path]

Name:
* cpt.ljn'path-module,
* cpt.ljn'path-object,
* cpt.ljnm.path,
* cpt.ljnmPath,
* cpt.ljnpath,

Whole-chain:
* module-instance,
* most-whole-object (global),

Generic-chain:
* Object.prototype, (mPath.__proto__ === Object.prototype //true)

Member:
// ljn.6-2-2
// Object.getOwnPropertyNames(mPath).sort()
[ '_makeLong', 'basename', 'delimiter', 'dirname', 'extname', 'format', 'isAbsolute', 'join', 'normalize', 'parse', 'posix', 'relative', 'resolve', 'sep', 'win32' ]

ljnm.core.readline-object (core 2.stable)

Description:
The readline module provides an interface for reading data from a Readable stream (such as process.stdin) one line at a time.
It can be accessed using:
const readline = require('readline');
The following simple example illustrates the basic use of the readline module.
const readline = require('readline');

const rl = readline.createInterface({
input: process.stdin,
output: process.stdout
});

rl.question('What do you think of Node.js? ', (answer) => {
// TODO: Log the answer in a database
console.log('Thank you for your valuable feedback:', answer);

rl.close();
});

Note Once this code is invoked, the Node.js application will not terminate until the readline.Interface is closed because the interface waits for data to be received on the input stream.

[https://nodejs.org/docs/v6.3.1/api/readline.html#readline_readline]

Name:
* cpt.ljn'readline-module,
* cpt.ljn'readline-object,
* cpt.ljnm.readline,
* cpt.ljnmReadline,
* cpt.ljn'readline,
* cpt.ljnreadline,

Whole-chain:
* module-instance,
* most-whole-object (global),

Generic-chain:
* Object.prototype, (mReadline.__proto__ === Object.prototype //true)

Member:
// ljn.6-2-2
// Object.getOwnPropertyNames(mReadline).sort()
[ 'Interface', 'clearLine', 'clearScreenDown', 'codePointAt', 'createInterface', 'cursorTo', 'emitKeypressEvents', 'getStringWidth', 'isFullWidthCodePoint', 'moveCursor', 'stripVTControlCharacters' ]

ljnm.core.repl-object (core 2.stable) link,

ljnm.core.string_decoder-object (2.stable)

Description:
The string_decoder module provides an API for decoding Buffer objects into strings in a manner that preserves encoded multi-byte UTF-8 and UTF-16 characters.
It can be accessed using:
const StringDecoder = require('string_decoder').StringDecoder;
The following example shows the basic use of the StringDecoder class.
const StringDecoder = require('string_decoder').StringDecoder;
const decoder = new StringDecoder('utf8');

const cent = Buffer.from([0xC2, 0xA2]);
console.log(decoder.write(cent));

const euro = Buffer.from([0xE2, 0x82, 0xAC]);

console.log(decoder.write(euro));

[https://nodejs.org/docs/v6.3.1/api/string_decoder.html#string_decoder_stringdecoder]

Name:
* cpt.ljn'string_decoder-module,
* cpt.ljnm.string_decoder,
* cpt.ljnmString_decoder,

Whole-chain:
* module-instance,
* most-whole-object (global),

Generic-chain:
* Object.prototype, (mString_decoder.__proto__ === Object.prototype //true)

Member:
// ljn.6-2-2
// Object.getOwnPropertyNames(mString_decoder).sort()
[ 'StringDecoder' ]

ljnm.core.tls-object (core 2.stable)

Description:
The tls module provides an implementation of the Transport Layer Security (TLS) and Secure Socket Layer (SSL) protocols that is built on top of OpenSSL.
The module can be accessed using:
const tls = require('tls');

[https://nodejs.org/docs/v6.3.1/api/tls.html#tls_tls_ssl]

Name:
* cpt.ljn'tls-module,
* cpt.ljn'tls-object,
* cpt.ljnm.tls,
* cpt.ljnmTls,
* cpt.ljn'tls,
* cpt.ljntls,

Whole-chain:
* module-instance,
* most-whole-object (global),

Generic-chain:
* Object.prototype, (mTls.__proto__ === Object.prototype //true)

Member:
// ljn.6-2-2
// Object.getOwnPropertyNames(mTls).sort()
[ 'CLIENT_RENEG_LIMIT', 'CLIENT_RENEG_WINDOW', 'DEFAULT_CIPHERS', 'DEFAULT_ECDH_CURVE', 'SLAB_BUFFER_SIZE', 'SecureContext', 'Server', 'TLSSocket', 'checkServerIdentity', 'connect', 'convertALPNProtocols', 'convertNPNProtocols', 'createSecureContext', 'createSecurePair', 'createServer', 'getCiphers', 'parseCertString' ]

ljnm.core.url-object (core 2.stable)

Description:
The url module provides utilities for URL resolution and parsing.
It can be accessed using:
const url = require('url');

[https://nodejs.org/docs/v6.3.1/api/url.html#url_url]

Name:
* cpt.ljn'url-module,
* cpt.ljn'url-object,
* cpt.ljnm.url,
* cpt.ljnmUrl,
* cpt.ljn'url,
* cpt.ljnurl,

Whole-chain:
* module-instance,
* most-whole-object (global),

Generic-chain:
* Object.prototype, (mUrl.__proto__ === Object.prototype //true)

Member:
// ljn.6-2-2
// Object.getOwnPropertyNames(mUrl).sort()
[ 'Url', 'format', 'parse', 'resolve', 'resolveObject' ]

ljnm.core.util-object (core 2.stable)

Description:
These functions are in the module 'util'.
Use require('util') to access them.

[http://nodejs.org/api/all.html#all_util]

Name:
* cpt.ljn'util-module,
* cpt.ljn'util-object,
* cpt.ljnm.util,
* cpt.ljnmUtil,
* cpt.ljn'util,
* cpt.ljnutil,

Whole-chain:
* module-instance,
* most-whole-object (global),

Generic-chain:
* Object.prototype, (mUtil.__proto__ === Object.prototype //true)

ljnutil'member

ljnutil'Member:
// ljn.6-2-2
// Object.getOwnPropertyNames(mUtil).sort()
[ '_errnoException', '_exceptionWithHostPort', '_extend', 'debug', 'debuglog', 'deprecate', 'error', 'format', 'inherits', 'inspect', 'isArray', 'isBoolean', 'isBuffer', 'isDate', 'isError', 'isFunction', 'isNull', 'isNullOrUndefined', 'isNumber', 'isObject', 'isPrimitive', 'isRegExp', 'isString', 'isSymbol', 'isUndefined', 'log', 'print', 'puts' ]
===
mUtil.format(format, [...])
mUtil.debug(string)
mUtil.error([...])
mUtil.puts([...])
mUtil.print([...])
mUtil.log(string)
mUtil.inspect(object, [options])
mUtil.isArray(object)
mUtil.isRegExp(object)
mUtil.isDate(object)
mUtil.isError(object)
mUtil.pump(readableStream, writableStream, [callback])
mUtil.inherits(constructor, superConstructor)

ljnm.core.vm-object (core 2.stable)

Description:
The vm module provides APIs for compiling and running code within V8 Virtual Machine contexts.
It can be accessed using:
const vm = require('vm');
javascript code can be compiled and run immediately or compiled, saved, and run later.

[https://nodejs.org/docs/v6.3.1/api/vm.html#vm_executing_javascript]

Name:
* cpt.ljn'vm-module,
* cpt.ljn'vm-object,
* cpt.ljnm.vm,
* cpt.ljnmVm,
* cpt.ljn'vm,
* cpt.ljnvm,

Whole-chain:
* module-instance,
* most-whole-object (global),

Generic-chain:
* Object.prototype, (mVm.__proto__ === Object.prototype //true)

ljnmVm'Member:
// ljn.6-2-2
// Object.getOwnPropertyNames(mVm).sort()
[ 'Script', 'createContext', 'createScript', 'isContext', 'runInContext', 'runInDebugContext', 'runInNewContext', 'runInThisContext' ]

ljnm.core.zlib-object (core 2.stable)

Description:
The zlib module provides compression functionality implemented using Gzip and Deflate/Inflate.
It can be accessed using:
const zlib = require('zlib');

[https://nodejs.org/docs/v6.3.1/api/zlib.html#zlib_zlib]

Name:
* cpt.ljn'zlib-module,
* cpt.ljn'zlib-object,
* cpt.ljnm.zlib,
* cpt.ljnmZlib,
* cpt.ljn'zlib,
* cpt.ljnzlib,

Whole-chain:
* module-instance,
* most-whole-object (global),

Generic-chain:
* Object.prototype, (mZlib.__proto__ === Object.prototype //true)

Member:
// ljn.6-3-1
// Object.getOwnPropertyNames(mZlib).sort()
[ 'Deflate', 'Gunzip', 'Inflate', 'Unzip', 'ZLIB_VERSION', 'Z_BEST_SPEED', 'Z_BUF_ERROR', 'Z_DEFAULT_CHUNK', 'Z_DEFAULT_LEVEL', 'Z_DEFAULT_STRATEGY', 'Z_ERRNO', 'Z_FINISH', 'Z_FULL_FLUSH', 'Z_MAX_CHUNK', 'Z_MAX_MEMLEVEL', 'Z_MEM_ERROR', 'Z_MIN_LEVEL', 'Z_MIN_WINDOWBITS', 'Z_NO_COMPRESSION', 'Z_OK', 'Z_RLE', 'Z_STREAM_ERROR', 'Z_VERSION_ERROR', 'codes', 'createDeflateRaw', 'createGzip', 'createInflateRaw', 'deflate', 'deflateRawSync', 'gunzip', 'gzip', 'inflate', 'inflateRawSync', 'unzip', 'unzipSync' ]

ljnm.CORE.NO

Description:
CoreNo-module is a-module created by the-language-creator|s.

Name:
* cpt.ljn'coreNo-module,
* cpt.ljn'non-native-module,
* cpt.ljnm.3rd-party,
* cpt.ljnm.non-builtIn,
* cpt.ljnm.custom,
* cpt.ljnm.internalNo,
* cpt.ljnm.nativeNo,

Specific:
* 3rd party modules written in javascript
* 3rd party modules with C/C++ addons
[https://github.com/rogerwang/node-webkit/wiki/Using-Node-modules]

ljnm.DIRECTORY

Description.short:
It is convenient to organize programs and libraries into self-contained directories, and then provide a single entry point to that library.
[https://nodejs.org/docs/v6.3.1/api/modules.html#modules_folders_as_modules]

Name:
* cpt.ljn'directory-module,
* cpt.ljn'folder-module,
* cpt.ljnm.directory,
* cpt.ljnm.folder,

Description:
Folders as Modules
It is convenient to organize programs and libraries into self-contained directories, and then provide a single entry point to that library. There are three ways in which a folder may be passed to require() as an argument.

The first is to create a package.json file in the root of the folder, which specifies a main module.
An example package.json file might look like this:
{ "name" : "some-library",
"main" : "./lib/some-library.js" }

If this was in a folder at ./some-library, then require('./some-library') would attempt to load ./some-library/lib/some-library.js.
This is the extent of Node's awareness of package.json files.
Note: If the file specified by the "main" entry of package.json is missing and can not be resolved, Node.js will report the entire module as missing with the default error:
Error: Cannot find module 'some-library'

If there is no package.json file present in the directory, then node will attempt to load an index.js or index.node file out of that directory.
For example, if there was no package.json file in the above example, then require('./some-library') would attempt to load:
./some-library/index.js
./some-library/index.node

[https://nodejs.org/docs/v6.3.1/api/modules.html#modules_folders_as_modules]
===
Directories as modules
You can organize your modules into directories, as long as you provide a point of entry for Node.

The easiest way to do this is to create the directory ./node_modules/mymodulename/, and put an index.js file in that directory.
The index.js file will be loaded by default.

Alternatively, you can put a package.json file in the mymodulename folder, specifying the name and main file of the module:
{
"name": "mymodulename",
"main": "./lib/foo.js"
}

This would cause the file ./node_modules/mymodulename/lib/foo.js to be returned from require('mymodulename').

Generally, you want to keep a single ./node_modules folder in the base directory of your app.
You can install new modules by adding files or directories to ./node_modules.
The best way to manage these modules is to use npm, which is covered briefly in the next section.

[http://book.mixu.net/node/single.html]

ljnm.FILE

Name:
* cpt.ljn'file-module,
* cpt.ljnm.file,

Description:
File Modules
If the exact filename is not found, then node will attempt to load the required filename with the added extension of .js, .json, and then .node.

.js files are interpreted as javascript text files, and .json files are parsed as JSON text files.
.node files are interpreted as compiled addon modules loaded with dlopen.

A module prefixed with '/' is an absolute path to the file.
For example, require('/home/marco/foo.js') will load the file at /home/marco/foo.js.

A module prefixed with './' is relative to the file calling require().
That is, circle.js must be in the same directory as foo.js for require('./circle') to find it.

Without a leading '/' or './' to indicate a file, the module is either a "core module" or is loaded from a node_modules folder.

If the given path does not exist, require() will throw an Error with its code property set to 'MODULE_NOT_FOUND'.

[https://nodejs.org/docs/v6.3.1/api/modules.html#modules_file_modules]

ljnm.MAIN

Description:
Main-module is a-module from which STARTS a-program or a-library.

Name:
* cpt.ljn'entry-point-module,
* cpt.ljn'main-module,
* cpt.ljnm.main,

Accessing the-main-module:
(link)

ljnm.MAIN.NO

Description:
Dependent-module is any module importing in another.

Name:
* cpt.ljn'dependent-module,
* cpt.ljn'dependency,
* cpt.ljn'mainNo-module,
* cpt.ljnm.mainNo,

ljnalgo'sut.API.NATIVE

Generic:
* ljs-native-api,

Name:
* cpt.ljn'API.native,
* cpt.ljn'native-API,

ljnapiNtv'WHOLE-PART-TREE

Description:
The-builtin-semantic-units have many relations.
The-whole-part-relations create a-whole-part-tree with 'global' the-most-whole-node.
[HmnSynagonism.2016-07-02]

Name:
* cpt.ljn'apiNtv'whole-part-tree,
* cpt.ljnapiNtv'whole-part-tree,
* cpt.ljn'native-whole-part-tree,
* cpt.ljn'wpt,
* cpt.ljnwpt,

ljn'Whole-part-tree:

  • global (ROOT of ljn whole-part-tree)
    • Array,
    • ArrayBuffer,
    • Boolean,
    • Buffer,
    • COUNTER_HTTP_CLIENT_REQUEST,
    • COUNTER_HTTP_CLIENT_RESPONSE,
    • COUNTER_HTTP_SERVER_REQUEST,
    • COUNTER_HTTP_SERVER_RESPONSE,
    • COUNTER_NET_SERVER_CONNECTION,
    • COUNTER_NET_SERVER_CONNECTION_CLOSE,
    • DTRACE_HTTP_CLIENT_REQUEST,
    • DTRACE_HTTP_CLIENT_RESPONSE,
    • DTRACE_HTTP_SERVER_REQUEST,
    • DTRACE_HTTP_SERVER_RESPONSE,
    • DTRACE_NET_SERVER_CONNECTION,
    • DTRACE_NET_STREAM_END,
    • DataView,
    • Date,
    • Error,
    • EvalError,
    • Float32Array,
    • Float64Array,
    • Function,
    • GLOBAL,
    • Infinity,
    • Int16Array,
    • Int32Array,
    • Int8Array,
    • Intl,
    • JSON,
    • Map,
    • Math,
    • NaN,
    • Number,
    • Object,
    • Promise,
    • Proxy,
    • RangeError,
    • ReferenceError,
    • Reflect,
    • RegExp,
    • Set,
    • String,
    • Symbol,
    • SyntaxError,
    • TypeError,
    • URIError,
    • Uint16Array,
    • Uint32Array,
    • Uint8Array,
    • Uint8ClampedArray,
    • WeakMap,
    • WeakSet,
    • clearImmediate,
    • clearInterval,
    • clearTimeout,
    • console,
    • decodeURI,
    • decodeURIComponent,
    • encodeURI,
    • encodeURIComponent,
    • escape,
    • eval,
    • global,
    • isFinite,
    • isNaN,
    • parseFloat,
    • parseInt,
    • process,
    • root,
    • setImmediate,
    • setInterval,
    • setTimeout,
    • undefined,
    • unescape,
    • MODULE-INSTANCE,

Global-member:
// ljn.6-3-1
> Object.getOwnPropertyNames(global).sort()
[ 'Array', 'ArrayBuffer', 'Boolean', 'Buffer', 'COUNTER_HTTP_CLIENT_REQUEST', 'COUNTER_HTTP_CLIENT_RESPONSE', 'COUNTER_HTTP_SERVER_REQUEST', 'COUNTER_HTTP_SERVER_RESPONSE', 'COUNTER_NET_SERVER_CONNECTION', 'COUNTER_NET_SERVER_CONNECTION_CLOSE', 'DTRACE_HTTP_CLIENT_REQUEST', 'DTRACE_HTTP_CLIENT_RESPONSE', 'DTRACE_HTTP_SERVER_REQUEST', 'DTRACE_HTTP_SERVER_RESPONSE', 'DTRACE_NET_SERVER_CONNECTION', 'DTRACE_NET_STREAM_END', 'DataView', 'Date', 'Error', 'EvalError', 'Float32Array', 'Float64Array', 'Function', 'GLOBAL', 'Infinity', 'Int16Array', 'Int32Array', 'Int8Array', 'Intl', 'JSON', 'Map', 'Math', 'NaN', 'Number', 'Object', 'Promise', 'Proxy', 'RangeError', 'ReferenceError', 'Reflect', 'RegExp', 'Set', 'String', 'Symbol', 'SyntaxError', 'TypeError', 'URIError', 'Uint16Array', 'Uint32Array', 'Uint8Array', 'Uint8ClampedArray', 'WeakMap', 'WeakSet', 'clearImmediate', 'clearInterval', 'clearTimeout', 'console', 'decodeURI', 'decodeURIComponent', 'encodeURI', 'encodeURIComponent', 'escape', 'eval', 'global', 'isFinite', 'isNaN', 'parseFloat', 'parseInt', 'process', 'root', 'setImmediate', 'setInterval', 'setTimeout', 'undefined', 'unescape' ]

ljnapiNtv.GENERIC-SPECIFIC-TREE

Description:
The native API[1] of ljn is-structured AND in a-generic-specific-tree because of the-inheritance (generic-specific) relations of its[1] members.
Object.prototype is the most generic object, like the-ljb-generic-specific-tree.

Name:
* cpt.ljn'API's-generic-specific-tree,
* cpt.ljnAPI's-generic-specific-tree,
* cpt.ljn'generic-specific-tree,
* cpt.ljngeneric-specific-tree,
* cpt.ljn'native-generic-specific-tree,
* cpt.ljnnative-generic-specific-tree,
* cpt.ljn'gst,
* cpt.ljngst,
* cpt.ljn'inheritance-tree,
* cpt.ljninheritance-tree,

ljn'Generic-specific-tree of ljn native-API:

ljnapiNtv'global-object (most-whole-object)

Description.short:
global is the most whole object in ljn-API's-whole-part-tree.
In ljb the most whole object is the-window.
The-members of the-global-object are-called also 'globals'.
[HmnSynagonism.2016-07-04]

Name:
* cpt.ljn'most-whole-object,
* cpt.ljn'global-object,
* cpt.ljn'object.global,
* cpt.ljn'global,
* cpt.ljnglobal,
* cpt.ljn'global-scope,
* cpt.ljnglobal-scope,
* cpt.ljn'global-namespace,
* cpt.ljnglobal-namespace,
* cpt.ljnmwo, {2016.07.22}
* cpt.ljngbl, {2016.07.01}
* ljn'most-whole-object-cpt,
* ljn'global-object-cpt,
* ljn'object.global-cpt,
* ljn'global-cpt,
* ljnglobal-cpt,
* ljn'global-scope-cpt,
* ljnglobal-scope-cpt,
* ljn'global-namespace-cpt,
* ljnglobal-namespace-cpt,
* ljnmwo-cpt,
* ljngbl-cpt,
===
DeprecationWarning: 'GLOBAL' is deprecated, use 'global'

Description:
Unlike the browser, Node does not have a window global object, but instead has two others: globals and process.
[https://www.airpair.com/javascript/node-js-tutorial#3-1-modules]
===
Node module has a number of variables which are available by default.
These are documented in the API docs: globals and process.

[http://book.mixu.net/node/single.html]
===
The global object is determined by the execution environment.
It is the window object in a web browser and the process object in a NodeJS script.

[http://rainsoft.io/gentle-explanation-of-this-in-javascript/]
===
global
{Object} The global namespace object.
In browsers, the top-level scope is the global scope.
That means that in browsers if you're in the global scope var something will define a global variable.
In Node this is different.
The top-level scope is not the global scope; var something inside a Node module will be local to that module.

[https://nodejs.org/docs/v6.3.1/api/globals.html#globals_global]
===
the global object, which is "DomWindow" in the browser and "global" in Node.
[http://book.mixu.net/node/single.html]

Whole-chain:
* nothing,

Generic-chain:
* global.__proto__ (?)
* Object.prototype (> global.__proto__.__proto__ === Object.prototype //true)
===
The-global is a-specific of Object.prototype.

ljnapiNtv'global-member

Description:
The-members of the-most-whole-object (global) are-called also 'globals'.
[HmnSynagonism.2016-07-02]
===
These objects are available in all modules.
Some of these objects aren't actually in the global scope but in the module scope - this will be noted.

[http://nodejs.org/api/all.html#all_global_objects]
===
Node module has a number of variables which are available by default.
These are documented in the API docs: globals and process.

[http://book.mixu.net/node/single.html]
===
Node is a javascript environment running in Google's V8 javascript engine.
As such, we should follow the best practices that we use for client-side development.
For example, we should avoid putting anything into the global scope.
That, however, is not always possible.
The global scope in Node is GLOBAL (as opposed to window in the browser), and you can easily create a global variable of function by omitting the var keyword, like this:
globalVariable = 1;
globalFunction = function () { ... };
Once again, globals should be avoided whenever possible.
So be careful and remember to use var when declaring a variable.

[http://net.tutsplus.com/tutorials/javascript-ajax/node-js-for-beginners/]

Name:
* cpt.ljn'global-member,
* cpt.ljnglobal-member,
* cpt.ljn'global-objects,
* cpt.ljnglobal-objects,
* cpt.ljn'globals,
* cpt.ljnglobals,
* ljn'global-member-cpt,
* ljnglobal-member-cpt,
* ljn'global-objects-cpt,
* ljnglobal-objects-cpt,
* ljn'globals-cpt,
* ljnglobals-cpt,

ljnapiNtv'ArrayBuffer-function

Name:
* cpt.ljn'ArrayBuffer,
* cpt.ljnArrayBuffer,
* ArrayBuffer-cpt,
* ljn'ArrayBuffer-cpt,
* ljnArrayBuffer-cpt,

Whole-chain:
* global,

Generic-chain:
* Function.prototype (> Object.getPrototypeOf(ArrayBuffer) === Function.prototype //true)
* Object.prototype,

ljnArrayBuffer'Member:
// ljn.6-2-2
> Object.getOwnPropertyNames(ArrayBuffer).sort()
[ 'arguments', 'caller', 'isView', 'length', 'name', 'prototype' ]
> Object.getOwnPropertyNames(ArrayBuffer.prototype).sort()
[ 'byteLength', 'constructor', 'slice' ]
> Object.getOwnPropertyNames(ArrayBuffer.prototype.__proto__).sort()
[ '__defineGetter__',
'__defineSetter__',
'__lookupGetter__',
'__lookupSetter__',
'__proto__',
'constructor',
'hasOwnProperty',
'isPrototypeOf',
'propertyIsEnumerable',
'toLocaleString',
'toString',
'valueOf' ]

ljnArrayBuffer.prototype'Member:
// ljn.6-2-2
> Object.getOwnPropertyNames(ArrayBuffer.prototype).sort()
[ 'byteLength', 'constructor', 'slice' ]

ljnapiNtv'Buffer-function (2.stable)

Name:
* cpt.ljn'Buffer,
* cpt.ljnBuffer,
* cpt.ljn'Buffer-function,
* cpt.ljn'Buffer-class,

Description:
The Buffer class is a global type for dealing with binary data directly.
It can be constructed in a variety of ways

[http://nodejs.org/api/all.html#all_class_buffer_1]
===
Pure javascript is Unicode friendly but not nice to binary data.
When dealing with TCP streams or the file system, it's necessary to handle octet streams.
Node has several strategies for manipulating, creating, and consuming octet streams.
Raw data is stored in instances of the Buffer class.
A Buffer is similar to an array of integers but corresponds to a raw memory allocation outside the V8 heap.
A Buffer cannot be resized.
The Buffer class is a global, making it very rare that one would need to ever require('buffer').
Converting between Buffers and javascript string objects requires an explicit encoding method.

[http://nodejs.org/api/all.html#all_buffer]

ljnapiNtv'console-object

Description:
Node provides a global 'console' object to which you can output strings using:
console.log('Hello');

[http://nodetuts.com/pdf/handson-nodejs-sample.pdf 36/147]
===
The console module provides a simple debugging console that is similar to the javascript console mechanism provided by web browsers.

The module exports two specific components:

A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to stdout and stderr.
Because this object is global, it can be used without calling require('console').

[https://nodejs.org/docs/v6.3.1/api/console.html#console_console]

Name:
* cpt.ljn'console,
* cpt.ljnconsole,
* cpt.ljn'console-object,
* cpt.ljnconsole-object,

Whole.chain:
* ljn-most-whole-object (global),

Generic-chain:
* Console.prototype, (> console.__proto__ === console.Console.prototype)
* Object.prototype, (> console.__proto__.__proto__ === Object.prototype //true)

ljnapiNtv'module-object (link)

ljnapiNtv'process-object

Description:
The process object is a global object and can be accessed from anywhere.
It is an instance of EventEmitter.

[http://nodejs.org/api/all.html#all_process_1]

Name:
* cpt.ljn'process-object,
* cpt.ljn'process,
* cpt.ljnm.process,
* cpt.ljnmProcess,
* cpt.ljnglobal.process,
* cpt.ljnprocess,

Whole-chain:
* global,

Generic-chain:
* (process.__proto__)
* events.EventEmitter.prototype (> process.__proto__.__proto__ === events.EventEmitter.prototype //true)
* Object.prototype (> process.__proto__.__proto__.__proto__ === Object.prototype //true)

ljnprocess.member

ljnprocess'Member:
//{ljn.6-2-2}
> Object.getOwnPropertyNames(process).sort()
[ 'EventEmitter', '_debugEnd', '_debugPause', '_debugProcess', '_events', '_eventsCount', '_exiting', '_fatalException', '_getActiveHandles', '_getActiveRequests', '_kill', '_linkedBinding', '_maxListeners', '_needImmediateCallback', '_promiseRejectEvent', '_rawDebug', '_startProfilerIdleNotifier', '_stopProfilerIdleNotifier', '_tickCallback', '_tickDomainCallback', 'abort', 'arch', 'argv', 'assert', 'binding', 'chdir', 'config', 'cpuUsage', 'cwd', 'debugPort', 'dlopen', 'domain', 'emitWarning', 'env', 'execArgv', 'execPath', 'exit', 'features', 'hrtime', 'kill', 'memoryUsage', 'moduleLoadList', 'nextTick', 'openStdin', 'pid', 'platform', 'reallyExit', 'release', 'stderr', 'stdin', 'stdout', 'title', 'umask', 'uptime', 'version', 'versions' ]
===
> Object.getOwnPropertyNames(process.__proto__)
[ 'constructor' ]
> Object.getOwnPropertyNames(process.__proto__.__proto__)
[ 'constructor', 'domain', '_events', '_maxListeners', 'setMaxListeners', 'getMaxListeners', 'emit', 'addListener', 'on', 'prependListener', 'once', 'prependOnceListener', 'removeListener', 'removeAllListeners', 'listeners', 'listenerCount', 'eventNames' ]
> Object.getOwnPropertyNames(process.__proto__.__proto__.__proto__)
[ 'constructor', 'toString', 'toLocaleString', 'valueOf', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', '__defineGetter__', '__lookupGetter__', '__defineSetter__', '__lookupSetter__', '__proto__' ]

ljnprocess.argv-array

Description:
An array containing the command line arguments.
The first element will be 'node', the second element will be the name of the javascript file.
The next elements will be any additional command line arguments.

// print process.argv
process.argv.forEach(function(val, index, array) {
console.log(index + ': ' + val);
});


This will generate:
$ node process-2.js one two=three four
0: node
1: /Users/mjr/work/node/process-2.js
2: one
3: two=three
4: four

[http://nodejs.org/api/process.html#process_process_argv]

Name:
* cpt.ljnpgm'command-line-arguments,
* cpt.ljnpgm'arguments,
* cpt.ljn'process.argv,
* cpt.ljn'process.argv-array,
* cpt.ljnprocess.argv,
* cpt.ljnprocess.argv-array,
* command-line-arguments-of-Node.js-program-cpt,
* ljnpgm'command-line-arguments-cpt,
* ljnpgm'arguments-cpt,
* ljn'process.argv-cpt,
* process.argv-cpt,

ljnprocess.versions-object

> process.versions
{ http_parser: '2.7.0',
node: '6.2.2',
v8: '5.0.71.52',
uv: '1.9.1',
zlib: '1.2.8',
ares: '1.10.1-DEV',
icu: '57.1',
modules: '48',
openssl: '1.0.2h' }

ljnapiNtv'require function

ljnapiNtv'CORE-MODULES link

ljnapiNtv'TIMER-FUNCTIONS

Description:
All of the timer functions are globals.
You do not need to require() this module in order to use them.

[https://nodejs.org/docs/v6.3.1/api/timers.html#timers_timers]

Name:
* cpt.ljn'timers,
* cpt.ljntimers,
* cpt.ljn'timer-functions,
* cpt.ljntimer-functions,
* ljn'timers-cpt,
* ljntimers-cpt,
* ljn'timer-functions-cpt,
* ljntimer-functions-cpt,

ljnalgo'PHRASE (ljsfrs)

Generic:
* ljs-phrase,

Name:
* cpt.ljn'phrase,
* cpt.ljnphrase,
* cpt.ljn'frs,
* cpt.ljnfrs,
* ljn'frs-cpt,
* ljnfrs-cpt,
* ljn'phrase-cpt,
* ljnphrase-cpt,

ljnalgo'SENTENCE (ljnstc)

Generic:
* ljs-sentence,

Name:
* cpt.ljn'sentence,
* cpt.ljnsentence,
* cpt.ljn'stc,
* ljnstc-cpt,
* ljn'sentence-cpt,
* cpt.ljnsentence,
* ljn'stc-cpt,
* ljnstc-cpt,

ljnstc.debugger

ljnalgo'ROOT-TREE

Generic:
* ljs-root-tree,

Name:
* cpt.ljn'algo-root-tree,
* cpt.ljnalgo-root-tree,
* cpt.ljn-algo-root,

Description:
The-root-tree is the-main-module.

ljnalgo.SPECIFIC

Name:
* cpt.ljn'algo.specific,
* cpt.ljnalgo.specific,

Specific:
Node.js is an extremely powerful and flexible technology that can solve a wide variety of problems.
I want everyone to remember that Node.js is only bound by your imagination.
The core libraries are very carefully designed to provide the puzzle pieces needed to build any picture.
Combine those with the modules available in npm and it's amazing how quickly you can begin building very complex and compelling applications.

[http://blog.modulus.io/absolute-beginners-guide-to-nodejs]

ljnalgo.AUTHENTICATION

Name:
* cpt.ljn'authentication,
* ljn'authentication-cpt,

AddressWpg:
* http://passportjs.org/
* http://www.sitepoint.com/http-authentication-in-node-js/

ljnalgo.FILE-SYSTEM

Description:
The file system functions consist of file I/O and directory I/O functions.
All of the file system functions offer both synchronous (blocking) and asynchronous (non-blocking) versions.
The difference between these two is that the synchronous functions (which have “Sync” in their name) return the value directly and prevent Node from executing any code while the I/O operation is being performed

[http://book.mixu.net/node/single.html]

Name:
* cpt.ljn'file-system-processing,
* cpt.ljn'processing.FILE-SYSTEM
* cpt.ljn'algo.fs,
* cpt.ljnalgo.fs,

AddressWpg:
* http://www.sitepoint.com/accessing-the-file-system-in-node-js/
* https://www.npmjs.org/package/delivery,

Module:
* fs-module,
* path-module,

ljnalgo.FILE-READING

Description:
The file system functions consist of file I/O and directory I/O functions.
All of the file system functions offer both synchronous (blocking) and asynchronous (non-blocking) versions.
The difference between these two is that the synchronous functions (which have “Sync” in their name) return the value directly and prevent Node from executing any code while the I/O operation is being performed:
var fs = require('fs');
var data = fs.readFileSync('./index.html', 'utf8');
// wait for the result, then use it
console.log(data);


Asynchronous functions return the value as a parameter to a callback given to them:
var fs = require('fs');
fs.readFile('./index.html', 'utf8', function(err, data) {
// the data is passed to the callback in the second argument
console.log(data);
});

...
You should use the asynchronous version in most cases, but in rare cases (e.g. reading configuration files when starting a server) the synchronous version is more appropriate.
Note that the asynchronous versions require a bit more thought, since the operations are started immediately and may finish in any order:
fs.readFile('./file.html', function (err, data) {
// ...
});
fs.readFile('./other.html', function (err, data) {
// ..
});

These file reads might complete in any order depending on how long it takes to read each file.
The simplest solution is to chain the callbacks:
fs.readFile('./file.html', function (err, data) {
// ...
fs.readFile('./other.html', function (err, data) {
// ...
});
});

[http://book.mixu.net/node/single.html]

ljnalgo.FILE-SERVER

AddressWpg:
* http://www.hongkiat.com/blog/node-js-server-side-javascript/,

ljnalgo.FILE-UPLOAD

AddressWpg:
* http://www.componentix.com/blog/13/file-uploads-using-nodejs-once-again,

ljnalgo.FILE-WRITING

Code.ljn:
var fs = require('fs');

var myData = {
  name:'test',
  version:'1.0'
}

var outputFilename = '/tmp/my.json';

fs.writeFile(outputFilename, JSON.stringify(myData, null, 4), function(err) {
  if(err) {
    console.log(err);
  } else {
    console.log("JSON saved to ");
  }
});

[http://stackoverflow.com/questions/5670752/write-pretty-json-to-file-using-node-js]

ljnalgo.HTML-MANIPULATION

Name:
* cpt.ljn'HML-manipulation,
* cpt.ljn'HML-processing,
* cpt.ljn'HTML-manipulation,
* cpt.ljn'HTML-processing,
* cpt.ljn'code.processing.HTML,

AddressWpg:
* https://github.com/Marak/html: jstohtml,

Specific:
* JSON-to-hml,
* Markdown-to-hml,

JSON-to-html

Name:
* cpt.ljn'JSON-to-hml,

AddressWpg:
* https://github.com/frozzare/json-to-html,

Markdown-to-html

Name:
* cpt.ljn'markdown-to-hml,

AddressWpg:
* https://github.com/vanetix/artificer,

ljnalgo.IO

Description:
Non-blocking I/O - every I/O call must take a callback, whether it is to retrieve information from disk, network or another process.
...
The premise of Node is that I/O is the main bottleneck of many (if not most) tasks.
A single I/O operation can take millions of CPU cycles, and in traditional, non-event-loop-based frameworks the execution is blocked for that time.
In Node, I/O operations such as reading a file are performed asynchronously.

[http://book.mixu.net/node/single.html]

Name:
* ljn.io,

ljnalgo.JSON-MANIPULATION

Description:
The JSON format is natively supported by Node.js.
Nothing needs to be added and no module inserted using require.
Converting JSON to object and object to JSON can be done using the JSON object and its parse and stringify methods.

Following code describes how to generate a string containing the JSON content for a javascript object.
var contact = {
id: 1,
lastName: "last name",
firstName: "first name"
};
var text = JSON.stringify(contact);
// contains {"id":1,"lastName":"last name","firstName":"first name"}


Following code describes how to get javascript object from a string containing the JSON content.
var text = "{\"id\":1,\"lastName\":\"last name\","
+"\"firstName\":\"first name\"}";
var contact = JSON.parse(text);

[http://templth.wordpress.com/2011/06/07/manipulating-json-and-xml-with-node-js/]

Name:
* cpt.ljn'json-manipulation,

ljnalgo.NETWORKING

Description:
Node's goal is to provide an easy way to build scalable network programs
[http://nodejs.org/about/]
===
Built-in support for the most important protocols (HTTP, DNS, TLS)
[http://book.mixu.net/node/single.html]

Name:
* cpt.ljn'networking,
* cpt.ljn'processing.NETWORKING,

Module:
* dgram: receive and send UDP packets.
* dns: asynchronous DNS resolution.
* http: create an HTTP server or client.
* https: implements http over TLS/SSL.
* net: create a TCP server client
* tls (ssl): uses OpenSSL to provide Transport Layer Security and/or Secure Socket Layer: encrypted stream communication.

ljnalgo.SFTP

Name:
* cpt.ljn'sftp,

Module:
* https://www.npmjs.org/package/grunt-ssh,
* https://www.npmjs.org/package/sftp-upload,

ljnalgo.PROCESSES

Name:
* cpt.ljn'processes,

API:
* child-process-module,
* process-object link,

ljnalgo.ROBOTICS

Name:
* cpt.ljn'robotics,

AddressWpg:
* https://medium.com/@leo/getting-started-with-javascript-robotics-5c54e716562c,

ljnalgo.SECURITY

Name:
* cpt.ljn'security,

Module:
* https://www.npmjs.org/package/hashids: A small Node.js class to generate YouTube-like hashes from one or many numbers.
Use hashids when you do not want to expose your database ids to the user.

ljnalgo.STREAMING

Description:
Stream everything; never force the buffering of data.
[http://book.mixu.net/node/single.html]

Name:
* cpt.ljn'streaming,

AddressWpg:
* http://www.sitepoint.com/introduction-to-streams/

Code.ljn:
Let's consider the following example:
var http = require('http')
  , fs = require('fs')
  ;

var server = http.createServer(function (req, res) {
  fs.readFile(__dirname + '/data.txt', function (err, data) {
    res.end(data);
  });
});

server.listen(8000);

This code works perfectly.
Nothing is wrong with it, except for the fact that Node.js
buffers the entire contents of data.txt before sending the data back to the client.
With the increase of clients requests your application could start to consume a lot of memory.
In addition clients will need to wait for the entire file to be read by the server application, resulting in increased latency.

Let's have a look at another example:
var http = require('http')
  , fs = require('fs')
  ;

var server = http.createServer(function (req, res) {
  var stream = fs.createReadStream(__dirname + '/data.txt');
  stream.pipe(res);
});
server.listen(8000);

Here, to overcome the scalability issues we use the streams API.
Using the stream object ensures that data.txt is sent to clients one chunk at a time as they are read from the disk, without server buffering and waiting times on the client.

[http://www.sitepoint.com/introduction-to-streams/]

ljn'stream

Description:
What are Streams?
Streams can be defined as a continuous flow of data that can be manipulated asynchronously as data comes in (or out).
In Node.js streams can be readable or writable.
A readable stream is an EventEmitter object that emits data events every time a chunk of data is received.
In our previous example a readable stream has been used to pipe the content of a file down to a HTTP client.
When the stream reaches the end of our file it emits an end event, indicating that no more data events will occur.
In addition a readable stream can be paused and resumed.

Writable streams, on the other hand, accept streams of data.
This type of stream inherits from the EventEmitter object too, and implements two methods: write() and end().
The first method writes data to a buffer and returns true if the data has been flushed correctly, or false if the buffer is full (in this case the data will be sent out later).The end() method simply indicates that the stream is finished.

[http://www.sitepoint.com/introduction-to-streams/]

ljnalgo.YAML-MANIPULATION

Name:
* cpt.ljn'YAML-manipulation,
* cpt.ljn'YAML-processing,

Module:
* https://www.npmjs.org/package/js-yaml,

Code.ljn:
* http://nodeexamples.com/2012/09/15/parsing-yaml-files-in-node-js-using-the-js-yaml-module/

ljnalgo.XML-MANIPULATION

Name:
* cpt.ljn'XML-manipulation,
* cpt.ljn'XML-processing,

AddressWpg:
* http://www.rackspace.com/blog/node-elementtree-node-js-library-to-build-and-parse-xml-documents/
* elementtree-module,

ljnalgo.LIBRARY (ljnlbr)

Generic:
* ljs-library,

Name:
* cpt.ljn'library,
* cpt.ljnlibrary,
* cpt.ljn'lbr,
* cpt.ljnlbr,
* ljn'library-cpt,
* ljnlibrary-cpt,
* ljn'lbr-cpt,
* ljnlbr-cpt,

ljnalgo.PROGRAM (ljnpgm)

Generic:
* ljs-program,

Name:
* cpt.ljn'application,
* cpt.ljn'apn,
* cpt.ljn'code.application,
* cpt.ljn'program,
* cpt.ljn'pgm, {2016.06.21}
* cpt.ljnpgm, {2016.06.21}
* cpt.ljn'app,
* cpt.ljnapp,
* ljn'pgm-cpt,
* ljn-pgm-cpt,
* Node.js-application-cpt,
* Node.js-program-cpt,
* nodejs-application-cpt,
* nodejs-program-cpt,
* pgmNodejs-cpt,

ljnpgm'Installing

Description:
Create a new directory and run the following commands.

npm install app:
downloads the-app

npm install:
installs the-dependencies on 'package.json'

node app:
runs the-app

ljnpgm'Executing

Description:
$ node app
or
you can make your file directly executable by changing permisions:
$ chmod o+x app.js
and insert the following as the first line of the file:
#!/usr/bin/env node
You can then execute the file directly:
$ ./app.js

[http://nodetuts.com/pdf/handson-nodejs-sample.pdf]

Name:
* cpt.ljnpgm'executing,
* cpt.ljnpgm-executing,
* ljnpgm'executing-cpt,
* ljnpgm-executing-cpt,
* node-app-running-cpt,

Command-line-arguments:
(link)

ljnpgm'Debugging (ljndbg)

Description:
Node.js includes a full-featured out-of-process debugging utility accessible via a simple TCP-based protocol and built-in debugging client.
To use it, start Node.js with the debug argument followed by the path to the script to debug; a prompt will be displayed indicating successful launch of the debugger:
$ node debug myscript.js
< debugger listening on port 5858
connecting... ok
break in /home/indutny/Code/git/indutny/myscript.js:1
  1 x = 5;
  2 setTimeout(() => {
  3 debugger;
debug>

Node.js's debugger client is not a full-featured debugger, but simple step and inspection are possible.

[https://nodejs.org/docs/v6.3.1/api/debugger.html#debugger_debugger]

Name:
* cpt.ljn'debugging,
* cpt.ljndbg,
* ljndbg-cpt,

AddressWpg:
* https://blog.risingstack.com/node-hero-node-js-debugging-tutorial/

ljndbg'debugger-statement

Name:
* cpt.ljndebugger,
* cpt.ljn'debugger-sentence,
* cpt.ljn'debugger-statement,

AddressWpg:
* https://blog.risingstack.com/node-hero-node-js-debugging-tutorial/,

ljnpgm'Dependency

Description:
At the most minimal definition, a dependency is just that - a package of code your application depends on.
Without this code, your application will not work correctly, and perhaps not even build.

[https://snyk.io/blog/whats-an-npm-dependency/]
===
If the-program has a-package.json-file, the-command npm install, installs the-dependencies of this program.

Name:
* cpt.ljn'dependency,
* cpt.ljn'dependencies,

AddressWpg:
* https://snyk.io/blog/whats-an-npm-dependency/

package.json'dependencies:
(link)

ljnpgm'Hosting

Description:
Node.js is a promising technology and an excellent choice for a high load application.
It has been proven by corporations, like Microsoft, eBay, and Yahoo.
If you're unsure about hosting your website/application, you can always use a cheap VPS solution or various cloud-based services, such as Microsoft Azure and Amazon EC2.
Both of these services provide scalable environments at a reasonable price.

[http://net.tutsplus.com/tutorials/javascript-ajax/node-js-for-beginners/]

Name:
* cpt.ljnpgm'deployment,
* cpt.ljn'hosting-application,

Resource:
* https://blog.risingstack.com/node-hero-deploy-node-js-heroku-docker/,
* https://blog.risingstack.com/moving-node-js-from-paas-to-kubernetes-tutorial/,

ljnpgm'hosting.SPECIFIC

Specific:
* AppFog,
* Coudnode,

Specific:
Here are some provider suggestions for Node.js hosting:
bejes.us
Cloud Foundry
Cloudnode
DotCloud
Duostack
Node.js works on a v8 environment – it is a virtual machine or a javascript engine that runs the javascript code, so for hosting you can't use the ordinary web hosts.
You will need the ones that have the v8 environment.

[http://www.hongkiat.com/blog/node-js-server-side-javascript/]

SPECIFIC

Name:
* cpt.ljn'apn.specific
* cpt.ljn'pgm.specific
* cpt.ljnpgm.specific

ljnpgm.HELLO-WORLD

The Hello World App:
Create a-directory.
Create on a-text-editor the-file, called filHello.js for example, and type the-code:
console.log('Hello World!');
Close the-file and type on the-same directory the-command:
node filHello.js
You should see 'Hello World!' displayed in the console.

The Hello World Web-Server:
An example of a web server written with Node.js which responds with 'Hello World':
const http = require('http');

const hostname = '127.0.0.1';
const port = 3000;

const server = http.createServer((req, res) => {
  res.statusCode = 200;
 res.setHeader('Content-Type', 'text/plain');
 res.end('Hello World\n');
});

server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});

To run the server, put the code into a file called example.js and execute it with Node.js:
$ node example.js
Server running at http://127.0.0.1:3000/

All of the examples in the documentation can be run similarly.

[https://nodejs.org/docs/v6.3.1/api/synopsis.html#synopsis_example]

ljnpgm.BLOG

Name:
* cpt.ljn'blog,

blogsiple:
* https://github.com/bergie/blogsiple,

ljnpgm.CMS

Name:
* cpt.ljn'cms,

Specific:
* http://stackoverflow.com/questions/3684743/cms-based-on-nodejs,
===
* https://github.com/joyent/node/wiki/modules#wiki-content-management,
* https://github.com/punkave/apostrophe, mogoDB.
* https://github.com/dpirek/nodejs-mvc-cms,

Cliste:
* https://github.com/bmarti44/Cliste,
- mogoDB,

InvaNode:
* https://github.com/i-vetrov/InvaNode-mongo,
InvaNode is a simple CMS.
It has base functionality for simple web-site with manageable content and template engine.
It is light and easy customizable.
- mogoDB.

ljnpgm.DESKTOP

Name:
* cpt.ljn'desktop-program,

AddressWpg:
* http://code.tutsplus.com/tutorials/ introduction-to-html5-desktop-apps-with-node-webkit--net-36296,

ljnpgm.EDITOR

Name:
* cpt'ljn'editor-program,
* cpt'ljn'editor-written-in-Node.js,

AddressWpg:
* https://www.npmjs.org/package/brackets,
* https://www.npmjs.org/package/scripted,
* https://github.com/soliton4/nodeMirror,

ljnpgm.elfinder

Description:
Command line app for searching in HTML files for elements that match a CSS selector
[https://npmjs.org/package/elfinder]

Name:
* cpt.ljnpgm.elfinder,
* elfinder-nodejs-app-cpt,

ljnpgm.FTP

Name:
* cpt.ljnpgm.ftp,
* cpt.ljn'ftp-application,

node-ftp:
node-ftp is an FTP client module for node.js that provides an asynchronous interface for communicating with an FTP server.
[https://github.com/mscdex/node-ftp]

ljnpgm.Geddy

Description:
An example of a popular Rails-like framework is Geddy
[http://dailyjs.com/2010/11/01/node-tutorial/]
===
A simple, structured web framework for Node
[http://geddyjs.org/]
===
Geddy is built on the same MVC principles that many popular frameworks are based on.
Every Geddy app has its models, controllers, and views as well as config files and routes.

[http://geddyjs.org/documentation]

Name:
* cpt.ljn'geddy,

ljnpgm.IRC

Name:
* cpt.ljn'IRC-pgm,

AddressWpg:
* https://tennu.github.io/:
Simple, Robust, Reusable IRC Bots

ljnpgm.PARSER

Name:
* cpt.ljn'parser-written-in-Node.js,

AddressWpg:
* https://github.com/joyent/node/wiki/Modules#parsers,

ljnpgm.slimnode

Description:
Slim Node is a blog engine that makes use of Markdown flat files as a blogging engine, making it easy to update and edit, without having to worry about having a chunky CMS like wordpress or Drupal to manage your content.
It is quick and light and the entire application logic (not including node dependencies) is only 56kb in size.
You can use Git to push updates to the articles folder, making it easy to update.

[http://localhost:8080/page/about]

Name:
* cpt.ljnpgm.slimnode,

ljnpgm.Wheat-blog

Description:
Wheat is a blogging engine that reads a git repo full of markdown articles and presents them as a website.
[https://github.com/creationix/wheat]
===
Tim Caswell's "Wheat" blog engine
[http://n8.io/starting-over/]

Name:
* cpt.ljnpgm.wheat,

ljnalgo.PACKAGE (ljnpkg)

Description.short:
A-Node.js-npm-package (default) is a-library or a-program with a-package.json-file.
[HmnSynagonism.2016-08-08] ===
A-Node.js-package is a-library or a-program with a-package.json-file.
[HmnSynagonism.2016-08-01]

Name:
* cpt.ljnnpm'package,
* cpt.ljn'package,
* cpt.ljnpackage,
* cpt.ljn'pkg,
* cpt.ljnpkg,
* cpt.npm'package,
* cpt.npmpkg,
* ljn'package-cpt,
* ljnpkg-cpt,
* Node.js-package-cpt,
* npm-package-cpt,
* npm'package-cpt,
* npmpkg-cpt,

Description:
What is a package?
A package is:
a) a folder containing a program described by a package.json file
b) a gzipped tarball containing (a)
c) a url that resolves to (b)
d) a <name>@<version> that is published on the registry with (c)
e) a <name>@<tag> that points to (d)
f) a <name> that has a "latest" tag satisfying (e)
g) a git url that, when cloned, results in (a).
Even if you never publish your package, you can still get a lot of benefits of using npm if you just want to write a node program (a), and perhaps if you also want to be able to easily install it elsewhere after packing it up into a tarball (b).

Git urls can be of the form:

git://github.com/user/project.git#commit-ish
git+ssh://user@hostname:project.git#commit-ish
git+http://user@hostname/project/blah.git#commit-ish
git+https://user@hostname/project/blah.git#commit-ish
The commit-ish can be any tag, sha, or branch which can be supplied as an argument to git checkout.
The default is master.

What is a module?
A module is anything that can be loaded with require() in a Node.js program.
The following things are all examples of things that can be loaded as modules:
- A folder with a package.json file containing a main field.
- A folder with an index.js file in it.
- A javascript file.
Most npm packages are modules, because they are libraries that you load with require.
However, there's no requirement that an npm package be a module! Some only contain an executable command-line interface, and don't provide a main field for use in Node programs.

Almost all npm packages (at least, those that are Node programs) contain many modules within them (because every file they load with require() is a module).

In the context of a Node program, the module is also the thing that was loaded from a file.
For example, in the following program:

var req = require('request')
we might say that "The variable req refers to the request module".

[https://www.npmjs.org/doc/faq.html#What-is-a-package]

Generic:
* ljs-package,

ljnpkg'package.json-file (ljnpkgjsn)

Description:
A package.json file contains an overview of your application.
There are a lot of available fields, but this is pretty much the minimum.
The dependencies section describes the name and version of the modules you'd like to install.
In this case I'll accept any version of Express 3.3.
You can list as many dependencies as you want in this section.
Now instead of installing each dependency separately, we can run a single command and install all of them.
> npm install
When you run this command npm will look in the current folder for a package.json file.
If it finds one, it will install every dependency listed.

[http://blog.modulus.io/absolute-beginners-guide-to-nodejs]
===
This document is all you need to know about what's required in your package.json file.
It must be actual JSON, not just a javascript object literal.
A lot of the behavior described in this document is affected by the config settings described in npm-config(7).

[https://npmjs.org/doc/files/package.json.html]

Name:
* cpt.ljn'package.json,
* cpt.ljn'package.json-file,
* cpt.ljn'pkgjson,
* cpt.ljnpkgjsn,
* ljn'package.json-cpt,
* ljn'package.json-file-cpt,
* ljn'pkgjson-cpt,
* ljnpkgjsn-cpt,
* npm'package.json-cpt,
* package.json-cpt,
* package.json-file-cpt,

AddressWpg:
* https://www.npmjs.org/doc/files/package.json.html,
* https://docs.npmjs.com/getting-started/using-a-package.json

ljnpkgjsn'field (member)

Name:
* cpt.ljnpkgjsn'field,
* cpt.ljnpkgjsn'member,

Specific:
=== mandatory:
* name,
* version,
===
* description,
* main,
* author,
* bin,
* bugs,
* config,
* contributors,
* cpu,
* dependencies,
* devDependencies,
* directories,
* engines,
* files,
* homepage,
* keywords,
* license,
* os,
* peerDependencies,
* preferGlobal,
* private,
* publishConfig,
* repository,
* scripts,

ljnpkgjsn'name-string

Description:
  "name" : "pkgname",
===
The most important things in your package.json are the name and version fields. Those are actually required, and your package won't install without them. The name and version together form an identifier that is assumed to be completely unique. Changes to the package should come along with changes to the version.

The name is what your thing is called.

Some rules:
- The name must be less than or equal to 214 characters. This includes the scope for scoped packages.
- The name can't start with a dot or an underscore.
- New packages must not have uppercase letters in the name.
- The name ends up being part of a URL, an argument on the command line, and a folder name. Therefore, - the name can't contain any non-URL-safe characters.

Some tips:
- Don't use the same name as a core Node module.
- Don't put "js" or "node" in the name. It's assumed that it's js, since you're writing a package.json file, and you can specify the engine using the "engines" field. (See below.)
- The name will probably be passed as an argument to require(), so it should be something short, but also reasonably descriptive.
- You may want to check the npm registry to see if there's something by that name already, before you get too attached to it. https://www.npmjs.com/

A name can be optionally prefixed by a scope, e.g. @myorg/mypackage. See npm-scope for more detail.

[https://docs.npmjs.com/files/package.json#name]

ljnpkgjsn'version-string

Description:
  "version" : "0.10.2", //major.minor.bug
===
The most important things in your package.json are the name and version fields.
Those are actually required, and your package won't install without them.
The name and version together form an identifier that is assumed to be completely unique.
Changes to the package should come along with changes to the version.

Version must be parseable by node-semver, which is bundled with npm as a dependency. (npm install semver to use it yourself.)

More on version numbers and ranges at semver(7).

[https://docs.npmjs.com/files/package.json#version]

ljnpkgjsn'author-string-or-object

Description:
  "author" : {
    "name" : "Eran Hammer",
    "email" : "eran@hueniverse.com",
    "url" : "http://hueniverse.com"
  },

===
The "author" is one person. "contributors" is an array of people. A "person" is an object with a "name" field and optionally "url" and "email", like this:
{ "name" : "Barney Rubble"
, "email" : "b@rubble.com"
, "url" : "http://barnyrubble.tumblr.com/"
}

Or you can shorten that all into a single string, and npm will parse it for you:
"Barney Rubble <b@rubble.com> (http://barnyrubble.tumblr.com/)"
Both email and url are optional either way.

npm also sets a top-level "maintainers" field with your npm user info.

[https://docs.npmjs.com/files/package.json#people-fields-author-contributors]

ljnpkgjsn'bin-string-or-object

Description:
  "bin" : "./path/to/program",
===
A lot of packages have one or more executable files that they'd like to install into the PATH. npm makes this pretty easy (in fact, it uses this feature to install the "npm" executable.)

To use this, supply a bin field in your package.json which is a map of command name to local file name. On install, npm will symlink that file into prefix/bin for global installs, or ./node_modules/.bin/ for local installs.

For example, myapp could have this:
{ "bin" : { "myapp" : "./cli.js" } }
So, when you install myapp, it'll create a symlink from the cli.js script to /usr/local/bin/myapp.

If you have a single executable, and its name should be the name of the package, then you can just supply it as a string. For example:
{ "name": "my-program"
, "version": "1.2.5"
, "bin": "./path/to/program" }

would be the same as this:
{ "name": "my-program"
, "version": "1.2.5"
, "bin" : { "my-program" : "./path/to/program" } }

[https://docs.npmjs.com/files/package.json#bin]

ljnpkgjsn'bugs-object

Description:
  "bugs" : { "url" : "https://github.com/user/my_package/issues" },
===
The url to your project's issue tracker and / or the email address to which issues should be reported. These are helpful for people who encounter issues with your package.

It should look like this:
{ "url" : "https://github.com/owner/project/issues"
, "email" : "project@hostname.com"
}

You can specify either one or both values. If you want to provide only a url, you can specify the value for "bugs" as a simple string instead of an object.

If a url is provided, it will be used by the npm bugs command.

[https://docs.npmjs.com/files/package.json#bugs]

ljnpkgjsn'config-object

Description:
  "config" : { "port" : "8080" },
===
A "config" object can be used to set configuration parameters used in package scripts that persist across upgrades. For instance, if a package had the following:
{ "name" : "foo"
, "config" : { "port" : "8080" } }

and then had a "start" command that then referenced the npm_package_config_port environment variable, then the user could override that by doing npm config set foo:port 8001.
See npm-config and npm-scripts for more on package configs.

[https://docs.npmjs.com/files/package.json#config]

ljnpkgjsn'contributors-array

Description:
  "contributors" : [{person1}, {person2}],
===
The "author" is one person. "contributors" is an array of people.
[https://docs.npmjs.com/files/package.json#people-fields-author-contributors]
===
DEFAULT VALUES
"contributors": [...]
If there is an AUTHORS file in the root of your package, npm will treat each line as a Name <email> (url) format, where email and url are optional. Lines which start with a # or are blank, will be ignored.

[https://docs.npmjs.com/files/package.json#default-values]

ljnpkgjsn'cpu-array

Description:
  "cpu" : [ "x64", "ia32" ],
===
If your code only runs on certain cpu architectures, you can specify which ones.
"cpu" : [ "x64", "ia32" ]
Like the os option, you can also blacklist architectures:
"cpu" : [ "!arm", "!mips" ]
The host architecture is determined by process.arch

[https://docs.npmjs.com/files/package.json#cpu]

ljnpkgjsn'dependencies-object

Description:
  "dependencies" : {
    "hoek": "0.7.x",
    "dyl" : "file:../dyl",
    "til" : "~1.2",
    "lat" : "latest"
  },

===
Dependencies are specified in a simple object that maps a package name to a version range. The version range is a string which has one or more space-separated descriptors. Dependencies can also be identified with a tarball or git URL.

Please do not put test harnesses or transpilers in your dependencies object. See devDependencies, below.

[https://docs.npmjs.com/files/package.json#dependencies]

ljnpkgjsn'description-string

Description:
  "description" : "A packaged foo fooer for fooing foos",
===
Put a description in it.
It's a string.
This helps people discover your package, as it's listed in npm search.

[https://docs.npmjs.com/files/package.json#description]as it's listed in npm search.

ljnpkgjsn'devDependencies-object

Description:
  "devDependencies" : {
    "lab" : "0.0.x",
    "complexity-report" : "0.x.x"
  },

===
If someone is planning on downloading and using your module in their program, then they probably don't want or need to download and build the external test or documentation framework that you use.

In this case, it's best to map these additional items in a devDependencies object.

These things will be installed when doing npm link or npm install from the root of a package, and can be managed like any other npm configuration param. See npm-config for more on the topic.

For build steps that are not platform-specific, such as compiling CoffeeScript or other languages to JavaScript, use the prepublish script to do this, and make the required package a devDependency.

For example:
{ "name": "ethopia-waza",
"description": "a delightfully fruity coffee varietal",
"version": "1.2.3",
"devDependencies": {
  "coffee-script": "~1.6.3"
},
"scripts": {
  "prepublish": "coffee -o lib/ -c src/waza.coffee"
},
"main": "lib/waza.js"
}
The prepublish script will be run before publishing, so that users can consume the functionality without requiring them to compile it themselves. In dev mode (ie, locally running npm install), it'll run this script as well, so that you can test it easily.

[https://docs.npmjs.com/files/package.json#devdependencies]

ljnpkgjsn'directories-object

Description:
  "directories" : {
    "lib" : "local/lib",
    "bin" : "local/binaries",
    "man" : "local/man",
    "doc" : "local/docs"
  },

===
The CommonJS Packages spec details a few ways that you can indicate the structure of your package using a directories object. If you look at npm's package.json, you'll see that it has directories for doc, lib, and man.

In the future, this information may be used in other creative ways.

directories.lib
Tell people where the bulk of your library is. Nothing special is done with the lib folder in any way, but it's useful meta info.

directories.bin
If you specify a bin directory in directories.bin, all the files in that folder will be added.

Because of the way the bin directive works, specifying both a bin path and setting directories.bin is an error. If you want to specify individual files, use bin, and for all the files in an existing bin directory, use directories.bin.

directories.man
A folder that is full of man pages. Sugar to generate a "man" array by walking the folder.

directories.doc
Put markdown files in here. Eventually, these will be displayed nicely, maybe, someday.

directories.example
Put example scripts in here. Someday, it might be exposed in some clever way.

[https://docs.npmjs.com/files/package.json#directories]

ljnpkgjsn'engines-object

Description:
  "engines" : { "node" : ">=0.10.3 <0.12", "npm" : "1.3.5" },
===
You can specify the version of node that your stuff works on:
{ "engines" : { "node" : ">=0.10.3 <0.12" } }
And, like with dependencies, if you don't specify the version (or if you specify "*" as the version), then any version of node will do.

If you specify an "engines" field, then npm will require that "node" be somewhere on that list. If "engines" is omitted, then npm will just assume that it works on node.

You can also use the "engines" field to specify which versions of npm are capable of properly installing your program. For example:
{ "engines" : { "npm" : "~1.0.20" } }
Note that, unless the user has set the engine-strict config flag, this field is advisory only.

[https://docs.npmjs.com/files/package.json#engines]

ljnpkgjsn'files-array

Description:
  "files" : [ filName, dirName],
===
The "files" field is an array of files to include in your project. If you name a folder in the array, then it will also include the files inside that folder. (Unless they would be ignored by another rule.)

You can also provide a ".npmignore" file in the root of your package or in subdirectories, which will keep files from being included, even if they would be picked up by the files array. The .npmignore file works just like a .gitignore.

Certain files are always included, regardless of settings:
package.json
README (and its variants)
CHANGELOG (and its variants)
LICENSE / LICENCE
Conversely, some files are always ignored:
.git
CVS
.svn
.hg
.lock-wscript
.wafpickle-N
*.swp
.DS_Store
._*
npm-debug.log

[https://docs.npmjs.com/files/package.json#files]

ljnpkgjsn'homepage-string

Description:
  "homepage" : "https://my-homepage/",
===
The url to the project homepage.
NOTE: This is not the same as "url". If you put a "url" field, then the registry will think it's a redirection to your package that has been published somewhere else, and spit at you.
Literally. Spit. I'm so not kidding.

[https://docs.npmjs.com/files/package.json#homepage]

ljnpkgjsn'keywords-array

Description:
  "keywords" : [ "http", "authentication" ],
===
Put keywords in it.
It's an array of strings.
This helps people discover your package as it's listed in npm search.

[https://docs.npmjs.com/files/package.json#keywords]s it's listed in npm search.

ljnpkgjsn'license-string

Description:
  "license" : "MIT",
===
You should specify a license for your package so that people know how they are permitted to use it, and any restrictions you're placing on it.

If you're using a common license such as BSD-2-Clause or MIT, add a current SPDX license identifier for the license you're using, like this:
{ "license" : "BSD-3-Clause" }
You can check the full list of SPDX license IDs. Ideally you should pick one that is OSI approved.

[https://docs.npmjs.com/files/package.json#license]

ljnpkgjsn'main-string

Description:
  "main" : "index",
===
The main field is a module ID that is the primary entry point to your program.
That is, if your package is named foo, and a user installs it, and then does require("foo"), then your main module's exports object will be returned.

This should be a module ID relative to the root of your package folder.

For most modules, it makes the most sense to have a main script and often not much else.

[https://docs.npmjs.com/files/package.json#main]

ljnpkgjsn'os-array

Description:
  "os" : [ "darwin", "linux" ],
===
You can specify which operating systems your module will run on:
"os" : [ "darwin", "linux" ]
You can also blacklist instead of whitelist operating systems, just prepend the blacklisted os with a '!':
"os" : [ "!win32" ]
The host operating system is determined by process.platform

It is allowed to both blacklist, and whitelist, although there isn't any good reason to do this.

[https://docs.npmjs.com/files/package.json#os]

ljnpkgjsn'peerDependencies-object

Description:
  "peerDependencies" : { "tea" : "2.x" },
===
In some cases, you want to express the compatibility of your package with a host tool or library, while not necessarily doing a require of this host. This is usually referred to as a plugin. Notably, your module may be exposing a specific interface, expected and specified by the host documentation.

For example:
{
  "name": "tea-latte",
  "version": "1.3.5",
  "peerDependencies": {
    "tea": "2.x"
  }
}

This ensures your package tea-latte can be installed along with the second major version of the host package tea only. npm install tea-latte could possibly yield the following dependency graph:
├── tea-latte@1.3.5
└── tea@2.2.0
NOTE: npm versions 1 and 2 will automatically install peerDependencies if they are not explicitly depended upon higher in the dependency tree. In the next major version of npm (npm@3), this will no longer be the case. You will receive a warning that the peerDependency is not installed instead. The behavior in npms 1 & 2 was frequently confusing and could easily put you into dependency hell, a situation that npm is designed to avoid as much as possible.

Trying to install another plugin with a conflicting requirement will cause an error. For this reason, make sure your plugin requirement is as broad as possible, and not to lock it down to specific patch versions.

Assuming the host complies with semver, only changes in the host package's major version will break your plugin. Thus, if you've worked with every 1.x version of the host package, use "^1.0" or "1.x" to express this. If you depend on features introduced in 1.5.2, use ">= 1.5.2 < 2".

[https://docs.npmjs.com/files/package.json#peerdependencies]

ljnpkgjsn'preferGlobal-boolean

Description:
  "preferGlobal" : true,
===
If your package is primarily a command-line application that should be installed globally, then set this value to true to provide a warning if it is installed locally.

It doesn't actually prevent users from installing it locally, but it does help prevent some confusion if it doesn't work as expected.

[https://docs.npmjs.com/files/package.json#preferglobal]

ljnpkgjsn'private-boolean

Description:
  "private" : true,
===
If you set "private": true in your package.json, then npm will refuse to publish it.

This is a way to prevent accidental publication of private repositories. If you would like to ensure that a given package is only ever published to a specific registry (for example, an internal registry), then use the publishConfig dictionary described below to override the registry config param at publish-time.

[https://docs.npmjs.com/files/package.json#private]

ljnpkgjsn'publishConfig-object

Description:
  "publishConfig" : { "registry" : "http://my-internal-registry.local" },
===
This is a set of config values that will be used at publish-time. It's especially handy if you want to set the tag, registry or access, so that you can ensure that a given package is not tagged with "latest", published to the global public registry or that a scoped module is private by default.

Any config values can be overridden, but of course only "tag", "registry" and "access" probably matter for the purposes of publishing.

See npm-config to see the list of config options that can be overridden.

[https://docs.npmjs.com/files/package.json#publishconfig]

ljnpkgjsn'repository-object

Description:
  "repository" : {
    "type" : "git",
    "url" : "git://github.com/hueniverse/hawk"
  },

===
Specify the place where your code lives. This is helpful for people who want to contribute. If the git repo is on GitHub, then the npm docs command will be able to find you.

Do it like this:
"repository" :
{ "type" : "git"
, "url" : "https://github.com/npm/npm.git"
}

"repository" :
{ "type" : "svn"
, "url" : "https://v8.googlecode.com/svn/trunk/"
}
The URL should be a publicly available (perhaps read-only) url that can be handed directly to a VCS program without any modification. It should not be a url to an html project page that you put in your browser. It's for computers.

For GitHub, GitHub gist, Bitbucket, or GitLab repositories you can use the same shortcut syntax you use for npm install:
"repository": "npm/npm"
"repository": "gist:11081aaa281"
"repository": "bitbucket:example/repo"
"repository": "gitlab:another/repo"

[https://docs.npmjs.com/files/package.json#repository]

ljnpkgjsn'scripts-object

Description:
  "scripts": { "test" : "make test-cov" },
===
You can specify the version of node that your stuff works on:
{ "engines" : { "node" : ">=0.10.3 <0.12" } }
And, like with dependencies, if you don't specify the version (or if you specify "*" as the version), then any version of node will do.

If you specify an "engines" field, then npm will require that "node" be somewhere on that list. If "engines" is omitted, then npm will just assume that it works on node.

You can also use the "engines" field to specify which versions of npm are capable of properly installing your program. For example:
{ "engines" : { "npm" : "~1.0.20" } }
Note that, unless the user has set the engine-strict config flag, this field is advisory only.

[https://docs.npmjs.com/files/package.json#scripts]

ljnpkgjsn.EXAMPLE

Example-of-package.json-file:
{
  "name" : "pkgname",
  "version" : "0.10.2",
  "description" : "A packaged foo fooer for fooing foos",
  "main" : "index.js",

  "author" : "Barney Rubble <b@rubble.com> (http://barnyrubble.tumblr.com/)",
  "bin" : "./path/to/program",
  "bugs" : { "url" : "https://github.com/user/my_package/issues" },
  "config" : { "port" : "8080" },
  "contributors" : [ {person1}, {person2}],
  "cpu" : [ "x64", "ia32" ],
  "dependencies" : { "hoek" : "0.7.x", "dyl" : "file:../dyl" },
  "devDependencies" : {
    "lab" : "0.0.x",
    "complexity-report" : "0.x.x"
  },
  "directories" : {
    "lib" : "local/lib",
    "bin" : "local/binaries",
    "man" : "local/man",
    "doc" : "local/docs"
  },
  "engines" : { "node" : ">=0.10.3 <0.12", "npm" : "1.3.5" },
  "files" : [ filName, dirName],
  "homepage" : "https://my-homepage/",
  "keywords" : [ "http", "authentication" ],
  "os" : [ "darwin", "linux" ],
  "peerDependencies" : { "tea" : "2.x" },
  "preferGlobal" : true,
  "private" : true,
  "publishConfig" : { "registry" : "http://my-internal-registry.local" },
  "repository" : {
    "type" : "git",
    "url" : "git://github.com/hueniverse/hawk"
  },
  "scripts" : { "test" : "make test-cov" }
}

ljnpkg'Installing

Description:
npm install 'package-name'
it will download the-package in node_modules in your current-directory.
npm install -g 'package-name'
it will install it globally.
===
There are two ways to install npm packages: locally or globally. You choose which kind of installation to use based on how you want to use the package.
If you want to use it as a command line tool, something like the grunt CLI, then you want to install it globally. On the other hand, if you want to depend on the package from your own module using something like Node's require, then you want to install locally.

[https://docs.npmjs.com/getting-started/installing-npm-packages-globally]

Name:
* cpt.ljn'package-installation,
* cpt.ljn'installing-package,

AddressWpg:
* https://docs.npmjs.com/getting-started/installing-npm-packages-locally,
* https://docs.npmjs.com/getting-started/installing-npm-packages-globally,

ljnpkg'Uninstalling

Description:
You can remove a package from your node_modules directory using npm uninstall :
npm uninstall lodash
To remove it from the dependencies in package.json, you will need to use the save flag:
npm uninstall --save lodash
Note: if you installed the package as a "devDependency" (i.e. with --save-dev) then --save won't remove it from package.json You have use --save-dev to uninstall it.

[https://docs.npmjs.com/getting-started/uninstalling-local-packages]
===
Global packages can be uninstalled with npm uninstall -g :
npm uninstall -g jshint

[https://docs.npmjs.com/getting-started/uninstalling-global-packages]

Name:
* cpt.ljnpkg'unistall,
* unistall-ljn-package-cpt,

ljnpkg'Updating

Description:
Every so often, you should update the packages you depend on so you can get any changes that have been made to code upstream.

To do this, run npm update in the same directory as your package.json file.

Test: Run npm outdated. There should not be any results.

[https://docs.npmjs.com/getting-started/updating-local-packages]
===
Updating global packages
To update global packages, you can use npm install -g <package>:
npm install -g jshint
To find out which packages need to be updated, you can use npm outdated -g --depth=0.

To update all global packages, you can use npm update -g. However, for npm versions less than 2.6.1, this script is recommended to update all outdated global packages.

[https://docs.npmjs.com/getting-started/updating-global-packages]

Name:
* cpt.ljnpkg'update,
* update-ljn-package-cpt,

ljnpkg'Publishing

Description:
You can publish any directory that has a package.json file, e.g. a node module.

Creating a user
To publish, you must have a user on the npm registry. If you don't have one, create it with npm adduser. If you created one on the site, use npm login to store the credentials on the client.

Test: Use npm config ls to ensure that the credentials are stored on your client. Check that it has been added to the registry by going to https://npmjs.com/~.

Publishing the package
Use npm publish to publish the package.

Note that everything in the directory will be included unless it is ignored by a local .gitignore or .npmignore file as described in npm-developers.

Also make sure there isn't already a package with the same name, owned by somebody else.

Test: Go to https://npmjs.com/package/<package>. You should see the information for your new package.

Updating the package
When you make changes, you can update the package using npm version <update_type>, where update_type is one of the semantic versioning release types, patch, minor, or major. This command will change the version number in package.json. Note that this will also add a tag with this release number to your git repository if you have one.

After updating the version number, you can npm publish again.

Test: Go to https://npmjs.com/package/<package>. The package number should be updated.

The README displayed on the site will not be updated unless a new version of your package is published, so you would need to run npm version patch and npm publish to have a documentation fix displayed on the site.

[https://docs.npmjs.com/getting-started/publishing-npm-packages]

Name:
* cpt.ljnpkg'publish,
* publish-ljn-package-cpt,

SPECIFIC

Name:
* cpt.ljnpkg.specific,

Specific:
* private-package,
* privateNo-package,
===
* local-package,
* localNo-package,

ljnpkg.SCOPED

Description:
All npm packages have a name. Some package names also have a scope. A scope follows the usual rules for package names (url-safe characters, no leading dots or underscores). When used in package names, preceded by an @-symbol and followed by a slash, e.g.
@somescope/somepackagename

Scopes are a way of grouping related packages together, and also affect a few things about the way npm treats the package.

Scoped packages are supported by the public npm registry. The npm client is backwards-compatible with un-scoped registries, so it can be used to work with scoped and un-scoped registries at the same time.

[https://docs.npmjs.com/misc/scopec]

Name:
* cpt.ljn'scoped-package,
* cpt.ljnpkg.scoped,
* scoped-package-cpt,

ljnpkg.amdlc

Description:
AMD Library Compiler
This is a Node.js AMD Library Compiler. It enables you to write code in an the AMD style and compile the modules into a standalone library file with all public modules exposed into the global namespace this is the opposite to application specific AMD module loaders like RequireJS.

When compiling AMD projects using this compileer you get three files:
- Inline minified file using Uglify-js
- Inline source file
- Development file that loads the modules synchronous (debug)

[https://npmjs.org/package/amdlc]

Name:
* cpt.ljn'amdlc-package,
* cpt.ljnpkg.amdlc,
* amdlc-cpt,

ljnpkg.browserify

Description.short:
browser-side require() the node way require('modules') in the browser

Use a node-style require() to organize your browser code and load modules installed by npm.

browserify will recursively analyze all the require() calls in your app in order to build a bundle you can serve up to the browser in a single script tag.
[https://www.npmjs.com/package/browserify]

Name:
* cpt.ljn'browserify-module,
* cpt.ljnm.browserify,
* browserify-cpt,

AddressWpg:
* http://browserify.org/
* https://github.com/substack/browserify-handbook,

Description:
Introduction to browserify
There's all this wonderful code on npm, the node.js package manager.
What if we could use that code in the browser?
Hey, we can.
Use browserify.
With browserify, we can use some core node modules and many of the thousands of modules on npm in our browser-side code.
We can also write our browser-side javascript in the node.js style by using require.

Install browserify:
npm install -g browserify
We use the -g option to install browserify globally on your machine, allowing you to use it on the command line.

Brief example:
// require the core node events module
var EventEmitter = require('events').EventEmitter;

//create a new event emitter
var emitter = new EventEmitter;

// set up a listener for the event
emitter.on('pizza', function(message){
console.log(message);
});

// emit an event
emitter.emit('pizza', 'pizza is extremely yummy');

Put the above code in a file named index.js.

Now, to be able to run this code in the browser, enter this command in the terminal:
browserify index.js > bundle.js
The bundle.js file now has your event emitter code along with any dependencies on core node modules and shims to make them work in the browser.

You can include bundle.js in your html now like any other javascript file.

Example:
<!DOCTYPE html>
<html>
<head>
<title>node / browserify example</title>
</head>
<body>

<script src="./bundle.js"></script>
</body>
</html>

That's it! Now you can use node modules and require in the browser!

Live reload development environment
If you're in the middle of writing code, you'll find running browserify in the terminal to regenerate bundle.js, then refreshing the browser to be time-consuming and annoying.

Enter beefy!

beefy is a command-line tool for automatically generating and serving your browserify bundles as you develop.
Each time you save your javascript file beefy will regenerate bundle.js and refresh the browser automatically.

Install beefy:
npm install -g beefy
Now, run this:
beefy index.js:bundle.js --live
The --live option enables the live reload functionality of beefy.

This will by default serve your index.html file at http://localhost:9966.
Open Chrome, enter that url, then open the javascript console by using the keyboard shortcut command+option+j.

You'll see pizza is extremely yummy in the javascript console!

[http://superbigtree.tumblr.com/post/54873453939/introduction-to-browserify]

ljnpkg.eslint

Description:
An AST-based pattern checker for JavaScript.
ESLint is a tool for identifying and reporting on patterns found in ECMAScript/JavaScript code. In many ways, it is similar to JSLint and JSHint with a few exceptions:
* ESLint uses Espree for JavaScript parsing.
* ESLint uses an AST to evaluate patterns in code.
* ESLint is completely pluggable, every single rule is a plugin and you can add more at runtime.

[https://npmjs.org/package/eslint]

Name:
* cpt.ljnpkg.eslint,
* cpt.ljn'eslint-package,
* eslint-cpt,
* ESLint-cpt,

Generic:
* ljn-code-analysis-tool,

ljnpkg.express

Description:
A simpler, Sinatra style framework is Express which has been around since June 2009, and is still regularly updated.
[http://dailyjs.com/2010/11/01/node-tutorial/]
===
Web Applications
Express is a minimal and flexible node.js web application framework, providing a robust set of features for building single and multi-page, and hybrid web applications.

[http://expressjs.com/]

Code.ljn:
var express = require('express');
var app = express();

app.get('/', function(req, res){
res.send('hello world');
});

app.listen(3333);
// ---
// http://localhost:3333

[http://expressjs.com/guide.html]

Name:
* cpt.ljn'express,
* cpt.ljnexpress,
* cpt.ljnm.express,
* cpt.ljnlbr.express,
* express-nodejs-framework-cpt,
* express-library-cpt,
* expressjs-cpt,
* ljnexpress-cpt,

ljnexpress'app.SERVER

Description:
Doing Something Useful - Express
Express is a framework that makes creating most normal websites very simple.
The first thing you have to do it install it.
Along with the node command you also have access to a command called "npm".
This tool gives you access to an enormous collection of modules created by the community, and one of them is Express.
$ cd /my/app/location
$ npm install express

When you install a module, it will put it in a node_modules folder inside your application directory.
You can now require it like any built-in module.
Let's create a basic static file server using Express.

my_static_file_server.js

var express = require('express'),
app = express();

app.use(express.static(__dirname + '/public'));

app.listen(8080);


$ node my_static_file_server.js
You now have a pretty capable static file server.
Anything you put in the /public folder can now be requested by your browser and displayed.
HTML, images, almost anything.
So for example, if you put an image called "my_image.png" inside the public folder, you can access it using your browser by going to http://localhost:8080/my_image.png.
Of course Express has many many more features, but you can look those up as you continue developing.

[http://blog.modulus.io/absolute-beginners-guide-to-nodejs]

ljnexpress'API

AddressWpg:
* http://expressjs.com/api.html,

ljnexpress'Resource

AddressWpg:
* http://expressjs.com/api.html,
* https://github.com/visionmedia/express/tree/master/examples,

ljnpkg.glob

Description:
Glob
Match files using the patterns the shell uses, like stars and stuff.

This is a glob implementation in javascript.
It uses the minimatch library to do its matching.

Attention: node-glob users!

The API has changed dramatically between 2.x and 3.x.
This library is now 100% javascript, and the integer flags have been replaced with an options object.

Also, there's an event emitter class, proper tests, and all the other things you've come to expect from node modules.

And best of all, no compilation!

[https://npmjs.org/package/glob]

Name:
* cpt.ljnpkg.glob,
* cpt.ljn'glob-package,

ljnpkg.jade

Description:
Jade is a high performance template engine heavily influenced by Haml and implemented with javascript for node.
[https://www.npmjs.org/package/jade]

Name:
* cpt.ljnpkg.jade,
* cpt.ljn'jade-package,
* jade-cpt,

AddressWpg:
* http://jade-lang.com/

ljnpkg.jake (ljnjake)

Description:
javascript build tool, similar to Make or Rake.
Built to work with Node.js.
Jake is a simple javascript build program with capabilities similar to the
regular make or rake command.
Jake has the following features:
* Jakefiles are in standard javascript syntax
* Tasks with prerequisites
* Namespaces for tasks
* Async task execution

[https://github.com/mde/jake]

Name:
* cpt.ljnjake,
* cpt.ljnpkg.jake,
* cpt.ljn'jake-package,
* jake-cpt,

Generic-chain:
* build-tool,
* ljs-based-task-runner,

AddressWpg:
* https://github.com/mde/jake,
* http://howtonode.org/intro-to-jake,

ljnjake'namespace

Description:
Use namespace to create a namespace of tasks to perform.
Call it with two arguments:

namespace(name, namespaceTasks);
Where is name is the name of the namespace, and namespaceTasks is a function with calls inside it to task or desc definining all the tasks for that namespace.

Here's an example:

desc('This is the default task.');
task('default', function () {
console.log('This is the default task.');
});

namespace('foo', function () {
desc('This the foo:bar task');
task('bar', function () {
console.log('doing foo:bar task');
});

desc('This the foo:baz task');
task('baz', ['default', 'foo:bar'], function () {
console.log('doing foo:baz task');
});

});
In this example, the foo:baz task depends on the the default and foo:bar tasks.

[https://github.com/mde/jake]

ljnjake'task

Description:
In your Jakefile, call task to define tasks.
Call it with three arguments (and one more optional argument):
task(name, dependencies, handler, [async]);
Where name is the string name of the task, dependencies is an array of the dependencies, and handler is a function to run for the task.

[http://howtonode.org/intro-to-jake]

Name:
* cpt.ljnjake'task,

ljnjake'task.DIRECTORY

Name:
* cpt.ljnjake'directory-task,

Description:
Create a directory-task by calling directory.

Directory-tasks create a directory for use with for file-tasks.
Jake checks for the existence of the directory, and only creates it if needed.

desc('This creates the bar directory for use with the foo-minified.js file-task.');
directory('bar');

This task will create the directory when used as a prerequisite for a file-task, or when run from the command-line.

[https://github.com/mde/jake]

ljnjake'task.FILE

Name:
* cpt.ljnjake'file-task,

Description:
File-tasks
Create a file-task by calling file.

File-tasks create a file from one or more other files.
With a file-task, Jake checks both that the file exists, and also that it is not older than the files specified by any prerequisite tasks.
File-tasks are particularly useful for compiling something from a tree of source files.

desc('This builds a minified JS file for production.');
file('foo-minified.js', ['bar', 'foo-bar.js', 'foo-baz.js'], function () {
// Code to concat and minify goes here
});

[https://github.com/mde/jake]

ljnjake'usage

Basic usage:
jake [options ...] [env variables ...] target

Options

-V/v
--version Display the Jake version.

-h
--help Display help message.

-f *FILE*
--jakefile *FILE* Use FILE as the Jakefile.

-C *DIRECTORY*
--directory *DIRECTORY* Change to DIRECTORY before running tasks.

-q
--quiet Do not log messages to standard output.

-J *JAKELIBDIR*
--jakelibdir *JAKELIBDIR* Auto-import any .jake files in JAKELIBDIR.
(default is 'jakelib')

-B
--always-make Unconditionally make all targets.

-t
--trace Enable full backtrace.

-T/ls
--tasks Display the tasks (matching optional PATTERN)
with descriptions, then exit.

[https://github.com/mde/jake#basic-usage]

Name:
* cpt.ljnjake'usage,

ljnpkg.jsdom

Name:
* ljsdom-cpt,
* cpt.ljnpkg.jsdom,
* cpt.ljn'jsdom-package,

AddressWpg:
* Transforming HTML with Node.js and jQuery: http://www.2ality.com/2012/02/jsdom.html,

ljnpkg.jshint

Description:
JSHint, A Static Code Analysis Tool for javascript

JSHint is a community-driven tool to detect errors and potential problems in javascript code and to enforce your team's coding conventions.
We made JSHint very flexible so you can easily adjust it to your particular coding guidelines and the environment you expect your code to execute in.

Our goal is to help javascript developers write complex programs without worrying about typos and language gotchas.

We believe that static code analysis programs—as well as other code quality tools—are important and beneficial to the javascript community and, thus, should not alienate their users.

For general usage and hacking information, visit our website: http://jshint.com/.

[https://npmjs.org/package/jshint]

Name:
* cpt.ljnpkg.jshint,
* cpt.ljn'jshint-package,
* jshint-cpt,
* JSHint-cpt,

Generic:
* ljn-code-analysis-tool,

ljnpkg.jslint

Description:
The JavaScript Code Quality Tool
node-jslint
Easily use JSLint from the command line.
jslint bin/jslint.js

[https://npmjs.org/package/jshint] ===
Resource: https://www.npmjs.com/package/jslint/tutorial,

Name:
* cpt.ljnpkg.jslint,
* cpt.ljn'jslint-package,
* jslint-cpt,
* JSLint-cpt,

Generic:
* ljn-code-analysis-tool,

ljnpkg.less

Description:
The dynamic stylesheet language.
http://lesscss.org

about
This is the javascript, and now official, stable version of LESS.
For more information on the language and usage visit lesscss.org.
More information also available in our wiki

[https://npmjs.org/package/less]

Name:
* cpt.ljnpkg.less,
* cpt.ljn'less-package,

ljnpkg.moment

Description:
Moment.js2.6.0
A javascript date library for parsing, validating, manipulating, and formatting dates.

[http://momentjs.com/]

Name:
* cpt.ljnpkg.moment,
* cpt.ljn'moment-package,
* momentjs-cpt,

ljnpkg.moxie-zip

Description:
moxie-zip

This is another zip library for node js.
We decided to write our own since we had issues with the current once that exists.

It's a very simple library:
var ZipWriter = require("moxie-zip").ZipWriter;
var zip = new ZipWriter();

zip.addFile("myfile.txt", "./myfile.txt");
zip.addData("myfile.txt", "Hello world!");
zip.addDir("mydir");

zip.toBuffer(function(buf) {
});

zip.saveAs("my.zip", function() {
  console.log("zip written.");
});

[https://npmjs.org/package/moxie-zip]

Name:
* cpt.ljnpkg.moxie-zip,
* cpt.ljn'moxie-zip-package,

ljnpkg.PDFKit

PDFKit
A PDF generation library for Node.js.
Description
PDFKit is a PDF document generation library for Node that makes creating complex, multi-page, printable documents easy.
It is written in pure CoffeeScript, but you can choose to use the API in plain 'ol javascript if you like.
The API embraces chainability, and includes both low level functions as well as abstractions for higher level functionality.
The PDFKit API is designed to be simple, so generating complex documents is often as simple as a few function calls.
Check out some of the documentation and examples to see for yourself!

[https://github.com/devongovett/pdfkit]

Name:
* cpt.ljnpkg.PDFKit,
* cpt.ljn'PDFKit-package,

ljnpkg.uglify-js

UglifyJS 2
UglifyJS is a javascript parser, minifier, compressor or beautifier toolkit.

This page documents the command line utility.
For API and internals documentation see my website.
There's also an in-browser online demo (for Firefox, Chrome and probably Safari).

[https://npmjs.org/package/uglify-js]

Name:
* cpt.ljnpkg.uglify-js,
* cpt.ljn'uglify-js-package,

ljn'Human (ljnhmn)

Name:
* cpt.ljn'human,
* cpt.ljnhuman,
* cpt.ljnhmn,

Specific:
* Dahl.Ryan,
* Caswell.Tim,

ljnhmn.Dahl.Ryan

Description:
It was 3 p.m. on November 8th, 2009.
In a room filled with people at JSConf Europe, Ryan Dahl showed off his pet project for the first time to a sizable audience.
Node.js, he called it.

[http://cloud9ide.posterous.com/our-commitment-to-the-nodejs-community]

Name:
* cpt.ljnhmn.Dahl.Ryan,
* Dahl.Ryan-cpt,
* Ryan-Dahl-cpt,

ljnhmn.Caswell.Tim

Description:
Tim Caswell, a prominent Node.js community member, well known for his howtonode.org blog,
[http://cloud9ide.posterous.com/our-commitment-to-the-nodejs-community]
===
* https://github.com/creationix,
* http://creationix.com/

Name:
* cpt.ljnhmn.Caswell.Tim,
* Caswell.Time-cpt,
* Tim-Caswell-cpt,

ljn'Organization (ljnogn)

Name:
* cpt.ljn'organization,
* cpt.ljnogn,

Specific:
* Joyent,
* Node.js-Foundation,

ljnogn.Joyent

Description:
Joyent is the corporate steward of Node.js, the world's best runtime for today's data-intensive, real-time applications.
Joyent offers exclusive debugging and performance analysis tools for Node.js applications.

[https://www.joyent.com/technology/nodejs]

Name:
* cpt.ljnogn.Joyent,
* cpt.ljn'Joyent,
* Joyent-cpt,

ljnogn.Node.js-Foundation

Description:
The Node.js Foundation's mission is to enable widespread adoption and help accelerate development of Node.js and other related modules through an open governance model that encourages participation, technical contribution, and a framework for long term stewardship by an ecosystem invested in Node.js' success.
[https://nodejs.org/en/foundation/]

Name:
* cpt.ljnogn.Node.js-Foundation,
* cpt.ljn'Node.js-Foundation,
* Node.js-Foundation-cpt,

ljn'Relation-to-browser-javascript

Description:
Node.js is different from client-side Javascript in that it removes certain things, like DOM manipulation, and adds support for evented I/O, processes, streams, HTTP, SSL, DNS, string and buffer processing and C/C++ addons.
[http://book.mixu.net/node/single.html]

Name:
* cpt.ljn'relation-to-ljb,
* Node.js-relation-to-browser-javascript-cpt,

ljn'Relation-to-PHP

Description:
Node.js uses an event-based server execution procedure rather than the multithreaded execution in PHP.
[http://www.hongkiat.com/blog/node-js-server-side-javascript/]

Name:
* cpt.ljn'relation-to-PHP,
* PHP-relation-to-nodejs-cpt,

ljn'Resource (ljnrsc)

Name:
* cpt.ljn'resource,
* cpt.ljnresource,
* cpt.ljnrsc,

AddressWpg:
* http://nodejs.org/
* docs.all: https://nodejs.org/docs/
* docs.latest: http://nodejs.org/docs/latest/api/index.html,
* https://github.com/joyent/node,
* http://nodemanual.org/latest/
* http://nodebits.org/
* http://howtonode.org/
* http://www.nodebeginner.org/
* http://cloud9ide.posterous.com/our-commitment-to-the-nodejs-community?..)
* http://docs.nodejitsu.com/
* http://nodester.com/
* https://github.com/joyent/node/wiki/
* https://github.com/joyent/node/wiki/Node-Hosting,
=== mail:
* http://groups.google.com/group/nodejs
* https://groups.google.com/group/nodejs?pli=1,
* Send email to this group: nodejs@googlegroups.com
=== IRC:
* http://webchat.freenode.net/?channels=node.js,
* #node.js room on irc.freenode.net
=== TUTORIAL
* http://blog.modulus.io/absolute-beginners-guide-to-nodejs,
* http://www.nodebeginner.org/
* http://debuggable.com/posts/understanding-node-js:4bd98440-45e4-4a9a-8ef7-0f7ecbdd56cb,

ljnrsc.APPLICATION

Program:
* http://stackoverflow.com/questions/3684743/cms-based-on-nodejs,
=== app creation ===
* https://github.com/rogerwang/node-webkit,
* http://net.tutsplus.com/tutorials/javascript-ajax/node-js-for-beginners/
* http://nodetuts.com/
* http://readwrite.com/2011/04/02/6-free-e-books-on-nodejs,

ljnrsc.BOOK

Name:
* cpt.ljn'book,

free: Mixu's Node Book:
* http://book.mixu.net/node/single.html,

free: Mastering-Node:
* http://visionmedia.github.com/masteringnode/book.html,
In Mastering Node we will discover how to write high concurrency web servers, utilizing the CommonJS module system, node's core libraries, third party modules, high level web development and more.

Professional Node.js: Building Javascript Based Scalable Software:
Pedro Teixeira
ISBN: 978-1-1181-8546-9
Paperback
408 pages
October 2012
£29.99 / €36.00
[http://eu.wiley.com/WileyCDA/WileyTitle/productCd-1118185463,descCd-google_preview.html]

Hands-on Node.js:
Pedro Teixeira
In this e-book we will analyze what makes Node a different proposal from all that is out there, why you should use it, and how to get started. It starts with an overview but quickly dives into the code, module by module. By the end of this book you should be able to build your own Node service producers and consumers, and also feel comfortable around the Node API and conventions.
By the end of it you should be able to build your own Node modules, as well as test and debug them.
[https://leanpub.com/hands-on-nodejs]

ljn'Security

Name:
* cpt.ljn'security,

AddressWpg:
* https://blog.nodeswat.com/set-up-a-secure-node-js-web-application-9256b8790f11,

Top Five Security Tips:
by Karl Düüna
Secure the environment
To build a secure system, you need to start from the ground up and invest time in securing the environment.
Otherwise your code might be secure, but attackers can still compromise your application by exploiting weaknesses on your servers instead.
Make sure you run up-to-date software, have secure authentication mechanisms, run the application under low privileges, and have decent logging.

Validate all input
Hacking in general means finding an unexpected usage for a system by introducing an unexpected input.
The best way to defend yourself is to allow as narrow of an input range as possible.
It is equally important to always validate that there is a match between the input and your expectations.

Secure your data
Data and databases are a critical part of most web applications and therefore a prime target for attackers.
While Node.js applications might be more inclined towards NoSQL, the principles of data protection are the same: always use authentication mechanisms, use varying levels of access, separate your customers' data as much as needed or possible, and encrypt the important parts of the database.

Protect your clients
Clients are probably the most valuable asset of your web application—they use the system and bring in the business.
So it is natural that you must protect them with the same vigilance.
This, alongside other defenses, means you must invest in protecting the client side of your application, including setting up CSRF and XSS defenses, protecting against clickjacking and unvalidated redirects.

Implement “Defense in Depth”
Cyber-defense is an asymmetrical problem: while crackers need only one of their attacks to succeed, you need all of your defenses to hold.
This is unrealistic, which is why you should always opt for “Defense In Depth.” Never assume that the outer defenses of your application are impenetrable.
Instead, set up layers upon layers of defensive mechanisms.
Even if the attacker manages to get through one layer, the damage they can do is limited.

[https://pragprog.com/book/kdnodesec/secure-your-node-js-web-application]

ljn'Tool

Generic:
* ljs-tool,

Name:
* cpt.ljn'tool,
* cpt.ljntool,

Specific:
* build-tool,
* code-analysis-tool,
* debugger-tool,
* editor-tool,
* package-manager-tool,
* testing-tool,
* version-manager-tool,
=== instance:
* interpreter-(runtime)-tool,
* npm-tool,
* REPL-tool,

ljntool.BUILD

Name:
* cpt.ljntool.build,
* cpt.ljn'build-tool,

Resource:
* http://blog.millermedeiros.com/node-js-as-a-build-script/,
* http://walkercoderanger.com/blog/2015/06/state-of-js-build-tools-2015/,

Specific:
* build-tools,
* Grunt,
* Gulp,
* Jake,

ljntool.CODE-ANALYSIS

Name:
* cpt.ljntool.code-analysis,
* cpt.ljn'code-analysis-tool,
* cpt.ljn'code-quality-tool,
* cpt.ljn'static-code-analysis-tool,

Resource:
* https://www.jetbrains.com/help/webstorm/2016.2/using-javascript-code-quality-tools.html,
* https://www.smashingmagazine.com/2015/02/avoid-javascript-mistakes-with-static-code-analyzer/,

Specific:
* ESLint,
* JSHint,
* JSLint,

ljntool.EDITOR

Name:
* cpt.ljn'editor,
* cpt.ljn'editor-tool,
* cpt.ljneditor,
* cpt.ljnedr,

ljnedr.BEST:
My answer is Eclipse with Nodeclipse plugin, comparing to Visual Studio and Sublime Text.
[http://lith.me/2013/04/06/the-best-editor-for-node-js-on-windows/]

ljnedr.scripted

Description:
Scripted is a fast and lightweight code editor with an initial focus on javascript editing.
Scripted is a browser based editor and the editor itself is served from a locally running Node.js server instance.

[https://github.com/scripted-editor/scripted]
===
nodejs-server, js client.

Name:
* cpt.ljn'scripted-editor,
* scripted_editor-cpt,

ljntool.VERSION-MANAGER

Name:
* cpt.ljn'version-manager,
* cpt.ljnversion-manager,

Specific:
* nvm-windows - Windows Only,
* nvmw - Windows Only,
* nodist - Windows Only,
* nvm - Mac/Linux Only,
* n - Mac/Linux Only,

ljntool.TESTING

Generic:
* ljs-testing-tool,

Name:
* cpt.ljntool.testing,
* cpt.ljn'testing,
* cpt.ljntesting,

Module:
* https://www.npmjs.org/package/nodeunit,

AddressWpg:
* http://visionmedia.github.io/mocha/
- https://brianstoner.com/blog/testing-in-nodejs-with-mocha/
* http://caolanmcmahon.com/posts/unit_testing_in_node_js/
* https://blog.risingstack.com/node-hero-node-js-unit-testing-tutorial/

ljn'tool.npm (ljnnpm)

Description.short:
npm is the default package manager for the JavaScript runtime environment Node.js.
[https://en.wikipedia.org/wiki/Npm_(software)]

Name:
* cpt.ljn'npm,
* cpt.ljnnpm,
* cpt.ljn'npm-tool,
* cpt.ljnnpm-tool,
* cpt.ljn'tool.npm,
* ljnnpm-cpt,
* node-package-manager-cpt,
* nodejs-package-manager-cpt,
* Node.js-package-manager-cpt,
* npm-cpt,
* npm-nodejs-package-manager-cpt,
* npm-package-manager-cpt,

Description:
npm is the package manager for the Node javascript platform.
It puts modules in place so that node can find them, and manages dependency conflicts intelligently.

It is extremely configurable to support a wide variety of use cases.
Most commonly, it is used to publish, discover, install, and develop node programs.

Run npm help to get a list of available commands.

[https://npmjs.org/doc/cli/npm.html]
===
Node.js has a package manager, called Node Package Manager (NPM).
It is automatically installed with Node.js, and you use NPM to install new modules.
To install a module, open your terminal/command line, navigate to the desired folder, and execute the following command:
1 npm install module_name
It doesn't matter what OS you have; the above command will install the module you specify in place of module_name.

[http://net.tutsplus.com/tutorials/javascript-ajax/node-js-for-beginners/]
===
npm is a package manager for Node.js that is run through the command line and manages dependencies for an application.
It is the predominant package manager for Node.js.
According to its author, npm is not an acronym for "Node Package Manager".[1]
As of Node.js version 0.6.3, npm is deployed and installed automatically with the environment.

[http://en.wikipedia.org/wiki/Npm_(software)]

Installation:
NPM is included by default with Node.JS, starting with version 0.6.3.

ljnnpm'Configuring

Name:
* cpt.ljnnpm'configuring,

AddressWpg:
* https://docs.npmjs.com/misc/config,
* https://docs.npmjs.com/files/npmrc,
* https://docs.npmjs.com/files/folders,
* https://docs.npmjs.com/files/package.json,

ljnnpm'Command

Name:
* cpt.ljnnpm'command,
* cpt.ljnnpm'cli-command,

Command-flag:
(link)

Specific:
* ljnnpm'access: Set access level on published packages
* ljnnpm'adduser: Add a registry user account
* ljnnpm'bin: Display npm bin folder
* ljnnpm'bugs: Bugs for a package in a web browser maybe
* ljnnpm'build: Build a package
* ljnnpm'bundle: REMOVED
* ljnnpm'cache: Manipulates packages cache
* ljnnpm'completion: Tab Completion for npm
* ljnnpm'config: Manage the npm configuration files
* ljnnpm'dedupe: Reduce duplication
* ljnnpm'deprecate: Deprecate a version of a package
* ljnnpm'dist-tag: Modify package distribution tags
* ljnnpm'docs: Docs for a package in a web browser maybe
* ljnnpm'edit: Edit an installed package
* ljnnpm'explore: Browse an installed package
* ljnnpm'find: Search for packages
* ljnnpm'help: Get help on npm
* ljnnpm'help-search: Search npm help documentation
* ljnnpm'init: Interactively create a package.json file
* ljnnpm'install: Install a package
* ljnnpm'install-test:
* ljnnpm'link: Symlink a package folder
* ljnnpm'logout: Log out of the registry
* ljnnpm'ls: List installed packages
* ljnnpm'npm: javascript package manager
* ljnnpm'outdated: Check for outdated packages
* ljnnpm'owner: Manage package owners
* ljnnpm'pack: Create a tarball from a package
* ljnnpm'ping: Ping npm registry
* ljnnpm'prefix: Display prefix
* ljnnpm'prune: Remove extraneous packages
* ljnnpm'publish: Publish a package
* ljnnpm'rebuild: Rebuild a package
* ljnnpm'repo: Open package repository page in the browser
* ljnnpm'restart: Restart a package
* ljnnpm'root: Display npm root
* ljnnpm'run-script: Run arbitrary package scripts
* ljnnpm's: Search for packages
* ljnnpm'se: Search for packages
* ljnnpm'search: Search for packages
* ljnnpm'shrinkwrap: Lock down dependency versions
* ljnnpm'star: Mark your favorite packages
* ljnnpm'stars: View packages marked as favorites
* ljnnpm'start: Start a package
* ljnnpm'stop: Stop a package
* ljnnpm'tag: Tag a published version
* ljnnpm'team: Manage organization teams and team memberships
* ljnnpm'test: Test a package
* ljnnpm'uninstall: Remove a package
* ljnnpm'unpublish: Remove a package from the registry
* ljnnpm'update: Update a package
* ljnnpm'version: Bump a package version
* ljnnpm'view: View registry info
* ljnnpm'whoami: Display npm username
[ljnnpm'https://docs.npmjs.com/]

ljnnpm'human

Name:
* cpt.ljnnpm'human,

Author:
* Schlueter.Isaac: original.

ljnnpm'Package (link)

ljnnpm'package.json-file (link)

ljnnpm'Resource

AddressWpg:
* https://npmjs.org/
* http://blog.keithcirkel.co.uk/how-to-use-npm-as-a-build-tool/
* https://github.com/joyent/node/wiki/modules, (deprecated)
* https://nodejsmodules.org/
* http://nodetoolbox.com/
* http://eirikb.github.io/nipster/ 37,093 entries

ljnnpm'semver

Description:
The semantic versioner for npm
Usage
$ npm install semver

semver.valid('1.2.3') // '1.2.3'
semver.valid('a.b.c') // null
semver.clean(' =v1.2.3 ') // '1.2.3'
semver.satisfies('1.2.3', '1.x || >=2.5.0 || 5.0.0 - 7.2.3') // true
semver.gt('1.2.3', '9.8.7') // false
semver.lt('1.2.3', '9.8.7') // true

[https://docs.npmjs.com/misc/semver]

Name:
* cpt.ljnnpm'semantic-versioner,
* cpt.ljnnpm'semver,

lngnpm.EVOLUTING

Version:
> npm -v
3.9.5
===
AddressWpg:
* https://github.com/npm/npm/tags,

ljn'tool.REPL (ljnrpl)

Description:
The repl module provides a Read-Eval-Print-Loop (REPL) implementation that is available both as a standalone program or includable in other applications.
It can be accessed using:
const repl = require('repl');

[https://nodejs.org/docs/v6.3.1/api/repl.html#repl_repl]

Name:
* cpt.ljn'REPL,
* cpt.ljn'REPL-program,
* cpt.ljn'Read-Eval-Print-Loop,
* cpt.ljnrpl,

Executing:
On a-terminal write node.
You will see its command-prompt (>).

Commands:
> .help
.break    Sometimes you get stuck, this gets you out
.clear    Alias for .break
.exit    Exit the repl
.help    Show repl options
.load    Load JS from a file into the REPL session
.save    Save all evaluated commands in this REPL session to a file

ljnrpl'module (core 2.stable)

Name:
* cpt.ljn'REPL-module,
* cpt.ljn'Read-Eval-Print-Loop,
* cpt.ljnrepl,

ljnrepl'Member:
// ljn.6-2-2
> Object.getOwnPropertyNames(repl).sort()

[ 'REPLServer', 'REPL_MODE_MAGIC', 'REPL_MODE_SLOPPY', 'REPL_MODE_STRICT', 'Recoverable', '_builtinLibs', 'repl', 'start', 'writer' ]

ljn'tool.Runtime (ljnrtm)

Description:
Node.js® is a javascript runtime built on Chrome's V8 javascript engine.
Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient.
Node.js' package ecosystem, npm, is the largest ecosystem of open source libraries in the world.

[https://nodejs.org/en/] {2016.07.01}

Name:
* cpt.Node.js,
* cpt.Node.js-interpreter,
* cpt.Node.js-runtime,
* cpt.ljn'interpreter,
* cpt.ljn'runtime,
* cpt.ljninterpreter,
* cpt.ljnruntime,

ljnrtm'installing

Windows

Description:
Download (https://nodejs.org/en/) msi file and run it.

Upgrading:
Download the new msi file and run it.

Ubuntu

Description:
At Least from Ubuntu 12.04, an old version (0.6.x) of Node is in the standard repository.
To install, just run:
> sudo apt-get install nodejs

[https://github.com/joyent/node/wiki/Installing-Node.js-via-package-manager#ubuntu-mint]

From-source

Building From Source
To build and install node from source, we first need to obtain the code.
The first method of doing so is via git, if you have git installed you can execute:
$ git clone http://github.com/ry/node.git && cd node
For those without git, or who prefer not to use it, we can also download the source via curl, wget, or similar:
$ curl -# http://nodejs.org/dist/node-v0.1.99.tar.gz > node.tar.gz
$ tar -zxf node.tar.gz
Now that we have the source on our machine, we can run ./configure which discovers which libraries are available for node to utilize such as OpenSSL for transport security support, C and C++ compilers, etc. make which builds node, and finally make install which will install node.

$ ./configure && make && make install

[http://visionmedia.github.com/masteringnode/book.html]

ljnrtm'Command-Line-Interface-option (ljnrtmopn)

Name:
* cpt.ljnrtmopn,
* cpt.ljnrtm'option,
* cpt.ljnrtm'CLI-option,

Specific:
Options
-v, --version
-h, --help
-e, --eval "script"
-p, --print "script"
-c, --check
-i, --interactive
-r, --require module
--no-deprecation
--trace-deprecation
--throw-deprecation
--no-warnings
--trace-warnings
--trace-sync-io
--zero-fill-buffers
--preserve-symlinks
--track-heap-objects
--prof-process
--v8-options
--tls-cipher-list=list
--enable-fips
--force-fips
--icu-data-dir=file
[https://nodejs.org/docs/v6.3.1/api/cli.html#cli_command_line_options]

ljnrtmopn.v

-v, --version
Added in: v0.1.3
Print node's version.
[https://nodejs.org/docs/v6.3.1/api/cli.html#cli_v_version]

ljnrtmopn.h

-h, --help
Added in: v0.1.3
Print node command line options. The output of this option is less detailed than this document.

[https://nodejs.org/docs/v6.3.1/api/cli.html#cli_h_help]

ljnrtmopn.e

-e, --eval "script"
Added in: v0.5.2
Evaluate the following argument as JavaScript.
The modules which are predefined in the REPL can also be used in script.

[https://nodejs.org/docs/v6.3.1/api/cli.html#cli_e_eval_script]

ljnrtmopn.p

-p, --print "script"
Added in: v0.6.4
Identical to -e but prints the result.

[https://nodejs.org/docs/v6.3.1/api/cli.html#cli_p_print_script]

ljnrtmopn.c

-c, --check
Added in: v5.0.0
Syntax check the script without executing.

[https://nodejs.org/docs/v6.3.1/api/cli.html#cli_c_check]

ljnrtmopn.i

-i, --interactive
Added in: v0.7.7
Opens the REPL even if stdin does not appear to be a terminal.

[https://nodejs.org/docs/v6.3.1/api/cli.html#cli_i_interactive]

ljnrtmopn.r

-r, --require module
Added in: v1.6.0
Preload the specified module at startup.

Follows require()'s module resolution rules.
module may be either a path to a file, or a node module name.

[https://nodejs.org/docs/v6.3.1/api/cli.html#cli_r_require_module]

ljnrtmopn.no-deprecation

--no-deprecation
Added in: v0.8.0
Silence deprecation warnings.

[https://nodejs.org/docs/v6.3.1/api/cli.html#cli_no_deprecation]

ljnrtmopn.trace-deprecation

--trace-deprecation
Added in: v0.8.0
Print stack traces for deprecations.

[https://nodejs.org/docs/v6.3.1/api/cli.html#cli_trace_deprecation]

ljnrtmopn.throw-deprecation

--throw-deprecation
Added in: v0.11.14
Throw errors for deprecations.

[https://nodejs.org/docs/v6.3.1/api/cli.html#cli_throw_deprecation]

ljnrtmopn.no-warnings

--no-warnings
Added in: v6.0.0
Silence all process warnings (including deprecations).

[https://nodejs.org/docs/v6.3.1/api/cli.html#cli_no_warnings]

ljnrtmopn.trace-warnings

--trace-warnings
Added in: v6.0.0
Print stack traces for process warnings (including deprecations).

[https://nodejs.org/docs/v6.3.1/api/cli.html#cli_trace_warnings]

ljnrtmopn.trace-sync-io

--trace-sync-io
Added in: v2.1.0
Prints a stack trace whenever synchronous I/O is detected after the first turn of the event loop.

[https://nodejs.org/docs/v6.3.1/api/cli.html#cli_trace_sync_io]

ljnrtmopn.zero-fill-buffers

--zero-fill-buffers
Added in: v6.0.0
Automatically zero-fills all newly allocated Buffer and SlowBuffer instances.

[https://nodejs.org/docs/v6.3.1/api/cli.html#cli_zero_fill_buffers]

ljnrtmopn.track-heap-objects

--track-heap-objects
Added in: v2.4.0
Track heap object allocations for heap snapshots.

[https://nodejs.org/docs/v6.3.1/api/cli.html#cli_track_heap_objects]

ljnrtmopn.prof-process

--prof-process
Added in: v6.0.0
Process v8 profiler output generated using the v8 option --prof.

[https://nodejs.org/docs/v6.3.1/api/cli.html#cli_prof_process]

ljnrtmopn.v8-options

--v8-options
Added in: v0.1.3
Print v8 command line options.

Note: v8 options allow words to be separated by both dashes (-) or underscores (_).

For example, --stack-trace-limit is equivalent to --stack_trace_limit.

[https://nodejs.org/docs/v6.3.1/api/cli.html#cli_v8_options]

ljnrtmopn.tls-cipher-list

--tls-cipher-list=list
Added in: v4.0.0
Specify an alternative default TLS cipher list. (Requires Node.js to be built with crypto support. (Default))

[https://nodejs.org/docs/v6.3.1/api/cli.html#cli_tls_cipher_list_list]

ljnrtmopn.enable-fips

--enable-fips
Added in: v6.0.0
Enable FIPS-compliant crypto at startup. (Requires Node.js to be built with ./configure --openssl-fips)

[https://nodejs.org/docs/v6.3.1/api/cli.html#cli_enable_fips]

ljnrtmopn.force-fips

--force-fips
Added in: v6.0.0
Force FIPS-compliant crypto on startup. (Cannot be disabled from script code.) (Same requirements as --enable-fips)

[https://nodejs.org/docs/v6.3.1/api/cli.html#cli_force_fips]

ljnrtmopn.icu-data-dir=file

--icu-data-dir=file
Added in: v0.11.15
Specify ICU data load path. (overrides NODE_ICU_DATA)

[https://nodejs.org/docs/v6.3.1/api/cli.html#cli_icu_data_dir_file]

ljnrtm'Environment-variables (ljnrtmenv)

Name:
* cpt.ljnrtmenv,
* cpt.ljnrtm'environment-variable,
* cpt.ljn'environment-variable,

Accessing:
process.env

Setting:
It depends on your system.
On linux with bash: export ENV_VAR=value
On windows: set ENV_VAR=value

Specific:
* NODE_DEBUG,
* NODE_DISABLE_COLORS,
* NODE_ICU_DATA,
* NODE_PATH,
* NODE_REPL_HISTORY,
[https://nodejs.org/docs/v6.3.1/api/cli.html#cli_environment_variables]

ljn'Learning

Generic:
* ljs-learning,

Name:
cpt.ljn'learning,
cpt.ljnlearning,

Resource:
* https://blog.risingstack.com/node-hero-tutorial-getting-started-with-node-js/,

ljn.EVOLUTING

Name:
* cpt.ljn.evoluting,
* cpt.ljn.evolution,
* cpt.ljn'evolution,
* ljnevolution-cpt,

Time:
Node.js was originally written in 2009 by Ryan Dahl.
The initial release supported only Linux.
Its development and maintenance was led by Dahl and later sponsored by Joyent.

Dahl was inspired to create Node.js after seeing a file upload progress bar on Flickr.
The browser did not know how much of the file had been uploaded and had to query the Web server.
Dahl desired an easier way.

Dahl demonstrated the project at the inaugural European JSConf on November 8, 2009.
Node.js combined Google's V8 javascript engine, an event loop and a low-level I/O API.
The project received a standing ovation.

In 2011, a package manager was introduced for the Node.js environment called npm.
The package manager makes it easier for programmers to publish and share source code of Node.js libraries and is designed to simplify installation, updating and uninstallation of libraries.

In June 2011, Microsoft and Joyent implemented a native Windows version of Node.js.
The first Node.js build supporting Windows was released in July 2011.

In January 2012, Dahl stepped aside, promoting coworker and npm creator Isaac Schlueter to manage the project.
In January 2014, Schlueter announced that Timothy J. Fontaine would lead the project.

In December 2014, Fedor Indutny started io.js, a fork of Node.js.
Due to the internal conflict over Joyent's governance, io.js was created as an open governance alternative with a separate technical committee.
Unlike Node.js, the authors planned to keep io.js up-to-date with the latest releases of the Google V8 javascript engine.

In February 2015, the intent to form a neutral Node.js Foundation was announced.
By June 2015, the Node.js and io.js communities voted to work together under the Node.js Foundation.

In September 2015, Node.js v0.12 and io.js v3.3 were merged back together into Node v4.0.
This brought V8 ES6 features into Node.js, and a long-term support release cycle.
As of 2016, the io.js website recommends that developers switch back to Node.js.

[https://en.wikipedia.org/wiki/Node.js#History]

ljn.version

Name:
* cpt.ljn.version,
* cpt.ljn'version,
* ljnversion-cpt,

resource:
* https://github.com/nodejs/node/blob/master/doc/changelogs/CHANGELOG_V6.md,

ljn.6.2016-04-26:
* changelog,
* The v6 release line will be covered by the Node.js Long Term Support plan starting in October 2016.
* 6.0.0 (current)- 6.3.0.2016-07-06 (current),

ljn.5.2015-10-29:
* changelog,
* Official support for the v5 release line is scheduled to expire around June 2016. Users of v5 should upgrade to Node.js v6.
* 5.0.0 (stable) - 5.12.0 (stable),

ljn.4.2015-10-07:
* changelog,
* Node.js v4 is covered by the Node.js Long Term Support Plan and will be supported actively until April 2017 and maintained until April 2018.
* 4.0.0 (stable) - 4.4.7.2016-06-28 (LTS),

ljn.0-12.2015-02-06:
* changelog,
* Node.js v0.12 is covered by the Node.js Long Term Support Plan and will be maintained until December 31st, 2016.
* 0.12.0 (stable) - 0.12.15-2016.06.23 (maintenance),

ljn.0-11.2013-03-28:
* changelog,
* 0.11.0 (unstable) - 0.11.14 (unstable),

ljn.0-10.2013-03-11:
* changelog,
* 0.10.0 (stable) - 0.10.46 (maintenance),

ljn.0-9.2012-07-20:
* changelog,
* 0.9.0 (unstable) - 0.9.12 (unstable),

ljn.0-8.2012-06-25:
* changelog,
* 0.8.0 (stable) - 0.8.25 (maintenance),

ljn.0-7.2012-01-16:
* changelog,
* 0.7.0 (unstable) - 0.7.12 (unstable),

ljn.0-6.2011-11-04:
* changelog,
* 0.6.0 (stable) - 0.6.20 (maintenance),

ljn.0-5.2011-07-05:
* changelog,
* 0.5.0 - 0.5.10,

ljn.0-4.2011-02-10:
* changelog,
* 0.4.0 - 0.4.12,

ljn.0-3.2010-10-23:
* changelog,
* 0.3.0 - 0.3.8,

ljn.0-2.2010-08-20:
* changelog,
* 0.2.0,

ljn.0-1.2009-06-30:
* changelog,
* 0.1.0 - 0.1.104,

ljn.0-0.2009-06-11:
* changelog,
0.0.3 - 0.0.6

ljs.EVOLUTING

Time: {2015}:
=== Node.js v4.0:
In September 2015, Node.js v0.12 and io.js v3.3 were merged back together into Node v4.0.
This brought V8 ES6 features into Node.js, and a long-term support release cycle.
As of 2016, the io.js website recommends that developers switch back to Node.js.

[https://en.wikipedia.org/wiki/Node.js#History]

Time: {2013}:
=== ISOMORPHIC-javascript:
In 2013, Airbnb was the first to use Node.js to provide isomorphic (also called universal or simply shared) javascript.
In the Node.js approach, the same framework is identically executed on the server side and client side.
On the server side, it provides an initial render of the page, and data could be provided through Node.js or through REST API calls.
On the client side, the framework binds to DOM elements, "rehydrates" (updates the initial server-side render provided by Node.js) the HTML, and makes asynchronous REST API calls whenever updated data is needed.
The biggest advantage Airbnb's javascript isomorphism had over Twitter's approach is the notion of a completely reusable rendering system.
Because the client-side framework is executed the same way on both server and client, rendering becomes much more manageable and debuggable in that the primary distinction between the server-side and client-side renders is not the language or templating system used, but rather what data is provisioned by the server and how.
From a prototype written in 10 days to being used across the stack by some of the largest websites in the world, long gone are the days of clunky browser implementations whose APIs changed depending on whether you were using Netscape or Internet Explorer.
It took javascript 20 years, but it is finally considered an equal partner to traditional, well-established server-side languages.

[http://buytaert.net/a-history-of-javascript-across-the-stack]

Time: {2009}:
=== Node.js:
Node.js was originally written in 2009 by Ryan Dahl.
Dahl demonstrated the project at the inaugural European JSConf on November 8, 2009.
Node.js combined Google's V8 javascript engine, an event loop and a low-level I/O API.
The project received a standing ovation.

[https://en.wikipedia.org/wiki/Node.js#History]

Time: {2008}:
=== V8, PERFORMANCE:
In 2008, Google launched Chrome with a faster javascript engine called V8.
The release announcement read:
"We also built a more powerful javascript engine, V8, to power the next generation of web applications that aren't even possible in today's browsers.".
At the launch, V8 improved javascript performance by 10x over Internet Explorer by compiling javascript code to native machine code before executing it.
This caught my attention because I had recently finished my PhD thesis on the topic of JIT compilation.
More importantly, this marked the beginning of different browsers competing on javascript performance, which helped drive javascript's adoption.

[http://buytaert.net/a-history-of-javascript-across-the-stack]

Time: {2005}:
=== Google Maps, Ajax:
A year later in 2005, Google launched Google Maps, which used the same technology as Gmail to transform online maps into an interactive experience.
With Google Maps, Google was also the first large company to offer a javascript API for one of their services allowing developers to integrate Google Maps into their websites.
Google's XMLHttpRequest approach in Gmail and Google Maps ultimately came to be called Ajax (originally "Asynchronous javascript and XML").
Ajax described a set of technologies, of which javascript was the backbone, used to create web applications where data can be loaded in the background, avoiding the need for full page refreshes.
This resulted in a renaissance period of javascript usage spearheaded by open source libraries and the communities that formed around them, with libraries such as Prototype, jQuery, Dojo and Mootools.
(We added jQuery to Drupal core as early as 2006.)

[http://buytaert.net/a-history-of-javascript-across-the-stack]

Time: {2004}:
=== Gmail:
For the first 10 years of javascript's life, professional programmers denigrated javascript because its target audience consisted of "amateurs".
That changed in 2004 with the launch of Gmail.
Gmail was the first popular web application that really showed off what was possible with client-side javascript.
Competing e-mail services such as Yahoo! Mail and Hotmail featured extremely slow interfaces that used server-side rendering almost exclusively, with almost every action by the user requiring the server to reload the entire web page.
Gmail began to work around these limitations by using XMLHttpRequest for asynchronous data retrieval from the server.
Gmail's use of javascript caught the attention of developers around the world.
Today, Gmail is the classic example of a single-page javascript app; it can respond immediately to user interactions and no longer needs to make roundtrips to the server just to render a new page.

[http://buytaert.net/a-history-of-javascript-across-the-stack]

Time: {1995}:
=== ANNOUNCEMENT:
MOUNTAIN VIEW, Calif. (December 4, 1995) -- Netscape Communications Corporation (NASDAQ: NSCP) and Sun Microsystems, Inc. (NASDAQ:SUNW), today announced javascript, an open, cross-platform object scripting language for the creation and customization of applications on enterprise networks and the Internet. The javascript language complements Java, Sun's industry-leading object-oriented, cross-platform programming language. The initial version of javascript is available now as part of the beta version of Netscape Navigator 2.0, which is currently available for downloading from Netscape's web site.
[https://web.archive.org/.../wp.netscape.com/newsref/pr/newsrelease67.html]

Meta Info

SEARCH THE-PAGE:
This page uses 'locator-names', names that when you find them, you find the-LOCATION of the-concept they denote.
Type CTRL+F "cpt.(ljs|ljb|ljn)words-of-concept's-name" or "words-of-name-cpt", to go to the-LOCATION of the-concept.
There are about 400 sub-concepts in this concept (ebook) with 1,400 names and 14,000 lines of hitp-document.

Webpage-Versions:
• version.last: filMcsLjs.html
• version.2-4.2016-08-09.last.minor: filCptLjs.html
• version.2.2016-08-04.last.minorNo (1-33): filCptLjs.2.2016-08-04.html (ljs, ljn)
• version.1-21.2016-05-26: lngJs.1-21.2016-05-26.html
• version.1-17.2016-05-23: lngJs.1-17.2016-05-23.html
• version.1-11.2016-05-18: lngJs.1-11.2016-05-18.html
• version.1.2016-05-10.created: lngJs.1.2016-05-10.html (ljb)

This page was visited times since {2016.05.04}

Page-path: javascript (ljs) ∈ modelInfoWorldhitpsynagonism.net

Support

Comments

comments powered by Disqus