Log message:
More http -> https.

Reviewed by hand.

Log message:
Update duktape and libduktape to 2.3.0

Changes since previous version (2.2.0):

pkgsrc: use the included Makefile.cmdline to build duktape, rather
than custom command in pkgsrc Makefile. Don't assume ${CC} is gcc
while doing so

XXX - it looks like the ABI has changed (silently) from 2.2.0 without
a corresponding libtool version bump from upstream. caveat buildor

2.3.0 (2018-08-04)
+ When C++ exception support is enabled use a separate
duk_fatal_exception (inherits from std::runtime_error) to propagate
fatal errors (uncaught errors, assertions) out of Duktape when using
the default fatal error handler (GH-1915)
+ Update UnicodeData.txt and SpecialCasing.txt used for building
internal Unicode control data to Unicode version 10.0.0 (GH-1851)
+ Add support for Symbol.hasInstance (@@hasInstance) check for
'instanceof' operator and duk_instanceof() API call; also add
Symbol.hasInstance and Function.prototype[@@hasInstance] (GH-1821)
+ Add support for Symbol.toStringTag (@@toStringTag) in
Object.prototype.toString() (GH-1822)
+ Add support for Symbol.isConcatSpreadable (@@isConcatSpreadable) in
Array.prototype.concat() (GH-1823)
+ Add support for Symbol.toPrimitive (@@toPrimitive) in ToPrimitive()
internal algorithm and duk_to_primitive() API call (GH-1825)
+ Invoke Proxy 'has' trap in Array.prototype.concat() when inspecting
the elements of the Proxy target (GH-1823)
+ Remove DUK_USE_NONSTD_ARRAY_CONCAT_TRAILER because the underlying
ES5.1 specification "bug" was fixed in ES2015 (GH-1823)
+ Remove DUK_USE_NONSTD_ARRAY_MAP_TRAILER because ES5.0/ES5.1 behavior
actually did match the "non-standard" behavior provided by the option
(GH-1823)
+ Add duk_random() to allow C code access to the same random number
source as ECMAScript code (GH-1815)
+ Add duk_push_new_target() to allow C code to access new.target; at
present this is for completeness because without actual class support
it's only useful to detect constructor calls which can already be done
using duk_is_constructor_call() (GH-1745)
+ Add experimental API call variants for plain C literals, for example
duk_push_literal(ctx, "key") and duk_get_prop_literal(ctx,
"propname"), which allow e.g.  better performance; calls added:
duk_push_literal(), duk_get_prop_literal(), duk_put_prop_literal(),
duk_has_prop_literal(), duk_del_prop_literal(),
duk_get_global_literal(), duk_put_global_literal() (GH-1805)
+ Add duk_get_global_heapptr() and duk_put_global_heapptr() for
completeness (GH-1805)
+ Automatically pin strings accessed using the C literal API call
variants such as duk_get_prop_literal(ctx, "propname") between
mark-and-sweep rounds to facilitate literal caching and to reduce
string table traffic; this behavior can be disabled by disabling
DUK_USE_LITCACHE_SIZE in configure.py (GH-1813)
+ Add a lookup cache for C literals to speed up string table lookups
when using API call variants such as duk_get_prop_literal(ctx,
"propname"); the cache relies on literals being pinned between
mark-and-sweep rounds, and can be disabled by disabling
DUK_USE_LITCACHE_SIZE in configure.py (GH-1813)
+ ES2015 Number constructor properties:  EPSILON, MIN_SAFE_INTEGER,
MAX_SAFE_INTEGER, isFinite(), isInteger(), isNaN(), isSafeInteger(),
parseInt(), parseFloat() (GH-1756, GH-1761)
+ Assume only natural alignment (DUK_USE_ALIGN_BY=8) on all platforms
to minimize compiler assumptions regarding unaligned accesses (which
can be an issue even on x86); applications working with a low memory
target may want to force DUK_USE_ALIGN_BY in configuration (GH-1783,
GH-1784)
+ Base64 decoder is now more lenient for padding:  accepts missing
padding ('Zm'), partial padding ('Zm='), standard padding ('Zm=='),
and extra padding ('Zm===' etc), also for concatenated documents
('Zm===Zm' decodes to 'ff' for example) (GH-1789)
+ Base64 encoder and decoder performance improvements for both fast
path and slow path variants (GH-1789)
+ Make base64 support optional and drop it from lowmem base
configuration; define DUK_USE_BASE64_SUPPORT to enable it (GH-1789)
+ Make hex support optional and drop it from lowmem base
configuration; define DUK_USE_BASE64_SUPPORT to enable it (GH-1789)
+ Add C++ name mangling wrappers (extern "C") for extras (GH-1780,
GH-1782)
+ Add a duk_uint64_t to duk_hbuffer_fixed forced alignment union trick
just in case double and uint64_t alignment requirements differ
(GH-1799)
+ Add a CBOR encoder/decoder as an extra (GH-1781, GH-1800, GH-1801)
+ Add a minimal ES2015 Promise polyfill into the distribution
(GH-1865)
+ Include <exception> only when compiling as C++ with C++ exception
support enabled (GH-1838, GH-1839)
+ Allow undefined timeout in eventloop example setTimeout() and
setInterval() bindings, minor cleanups and improvements (GH-1866,
GH-1879, GH-1884)
+ Revise Number.prototype.toFixed() 'this' binding and fractionDigits
argument validation order to match ES2015 where the 'this' binding is
validated first (GH-1887)
+ Add Makefile.jsoncbor to the distributable (GH-1885)
+ Makefile.sharedlibrary portability improvements (GH-1922, GH-1923)
+ Change spelling from ECMAScript to ECMAScript throughout the
internal source code; as far as external behavior is concerned this
only affects a few debug prints (GH-1894)
+ Fix NULL pointer dereference in error augmentation when
DUK_USE_TRACEBACKS was disabled (GH-1909)
+ Fix potential dangling pointer use in Duktape thread termination
handling; the dangling pointer could cause unsafe memory behavior
(GH-1845, GH-1868)
+ Fix performance.now() property attributes to 'wec' (earlier 'wc')
(GH-1821)
+ Fix debugger StepOver behavior when a tailcall happens in a nested
function (not the function where stepping started from) (GH-1786,
GH-1787)
+ Fix trailing single line comment handling for Function constructor;
new Function('return "foo" //') previously failed with SyntaxError
(GH-1757)
+ Fix some lexer bugs related to parsing in RegExp mode (interpret
leading '/' as part of a RegExp) or not (interpret '/' as division)
(GH-1779)
+ Fix DUK_BOOL_{MIN,MAX} defines for unsigned duk_bool_t (GH-1769)
+ Fix 'defined but not used' warning for Windows (GH-1775)
+ Fix potential uninitialized data use when Windows Date provider
FileTimeToSystemTime() or FileTimeToLocalFileTime() failed (GH-1953)
+ Fix some Clang warnings by avoiding undefined behavior by default,
define DUK_USE_ALLOW_UNDEFINED_BEHAVIOR to reduce the explicit
undefined behavior checks for better footprint/performance (GH-1777,
GH-1795, GH-1796, GH-1797, GH-1798)
+ Fix some compilation warnings triggered when DUK_NORETURN is not
defined; the internal DUK_WO_NORETURN() is used to include unreachable
dummy statements when the noreturn attribute is not available, e.g.
DUK_WO_NORETURN(return 0;); (GH-1790)
+ Fix a few casts in duk_trans_socket_windows.c to avoid errors in a
C++ build (GH-1773)
+ Fix harmless -Wcast-align warnings on armhf (GH-1793)
+ Various compiler warning fixes (GH-1788, GH-1932, GH-1924, GH-1950,
GH-1951, etc)
+ Add automatic workaround for union aliasing issues with FreeBSD +
-m32 + Clang prior to 5.0; the aliasing issues cause packed duk_tval
to work incorrectly (see
https://github.com/svaarala/duktape/blo … aliasing.c),
and the workaround is to use unpacked duk_tval prior to Clang 5.0
(GH-1764)

2.2.1 (2018-04-26)
+ Fix trailing single line comment handling for Function constructor;
new Function('return "foo" //') previously failed with SyntaxError
(GH-1757)
+ Fix DUK_BOOL_{MIN,MAX} defines for unsigned duk_bool_t (GH-1769)
+ Fix debugger StepOver behavior when a tailcall happens in a nested
function (not the function where stepping started from) (GH-1786,
GH-1787)
+ Fix potential dangling pointer use in Duktape thread termination
handling; the dangling pointer could cause unsafe memory behavior
(GH-1845, GH-1868)

Log message:
libduktape: Update lang/libduktape to 2.1

Reviewed and thanks to <agc>!

Changes:
=========================
Duktape 2.1 release notes
=========================
Release overview
================
Main changes in this release (see RELEASES.rst for full details):

* Performance, footprint, and portability improvements.
* API additions for more convenient handling of optional arguments:
  duk_opt_xxx() and duk_get_xxx_default().
* Allow duk_push_heapptr() for objects which have become unreachable and
  are pending finalization.  In such a case a duk_push_heapptr() cancels
  the pending finalizer call and automatically rescues the object.
* ES2015 additions like String.prototype.{startsWith,endsWith,includes}()
  and HTML comment syntax.  Non-standard shebang ("#!...") comment support.
* Finalizer handling rework for reference counting and mark-and-sweep to fix
  a few "side effect" bugs.  Also improved torture test coverage for \ 
ensuring
  side effects are handled correctly in Duktape internals.
* DUK_VERSION is now visible to duk_config.h so it's possible for duk_config.h
  to support multiple Duktape versions.  For example, some config options may be
  disabled prior to a certain patch level.

Upgrading from Duktape 2.0
==========================
No action (other than recompiling) should be needed for most users to upgrade
from Duktape v2.0.x.  Note the following:

* The Duktape thread used for finalizer calls is now always the initial thread
  (heap_thread), for both reference counting and mark-and-sweep triggered
  finalization.  This should be taken into account in finalizer functions;
  in particular, if there are multiple global environments, finalizers will
  execute in the first global environment created for the heap.
  Prior to 2.1 the finalizer thread could also be heap_thread but usually the
  current thread would be used.

=========================
Duktape 2.0 release notes
=========================
Release overview
================
Main changes in this release (see RELEASES.rst for full details):
* New tools/configure.py frontend tool replaces genconfig.py for configuring
  and preparing Duktape sources for build.
* Buffer handling has been simplified: Duktape.Buffer has been removed and is
  replaced by Uint8Array, plain buffers now behave like Uint8Array objects.
  Node.js Buffer behavior aligned with more recent Node.js Buffer API.
* Implement more ES2015 and ES2016 functionality, and align some ES5.1
  semantics with ES2015/ES2016.  Implement WHATWG Encoding API with
  TextEncoder() and TextDecoder() bindings.
* Some incompatible API changes, and several API additions.  API and config
  changes to avoid I/O dependencies (such as printf() and fopen()) in core
  Duktape code to simplify porting.
* More configuration flexibility in dropping Duktape specific functionality
  from build, e.g. coroutines and finalization.
* Disabled Ecmascript bindings are no longer present (instead of being present
  but throwing a TypeError).
* Built-in functionality moved to optional extras: print/alert bindings,
  logging, and module loader.  New optional extras include a Node.js-like
  module loader and a 'console' binding.
* Bug fixes, performance and footprint improvements.

The release has API incompatible changes, see upgrading notes below.

Upgrading from Duktape 1.x
==========================
There are API incompatible changes in this release.  Whenever possible the
incompatible changes cause a compilation error (or warning) so that fixing
call sites should be straightforward.  Below are instructions on how to
migrate from 1.x to 2.0.0.  There are also bug fixes and other minor
behavioral changes which may affect some applications, see ``RELEASES.rst``
for details.

There are backwards compatible providers for some removed/modified API calls
in ``extras/duk-v1-compat``.

Known issues
============
* Some non-compliant behavior for array indices near 2G or 4G elements.
* RegExp parser is strict and won't accept some real world RegExps which
  are technically not compliant with Ecmascript E5/E5.1 specification
  but allowed in ES2015 Annex B.
* Final mantissa bit rounding issues in the internal number-to-string
  conversion.

=========================
Duktape 1.6 release notes
=========================
Release overview
================
Main changes in this release (see RELEASES.rst for full details):

* Add duk_suspend() and duk_resume() API calls, backported from Duktape 2.0.

Upgrading from Duktape 1.5.x
============================
No action (other than recompiling) should be needed for most users to upgrade
from Duktape v1.5.x.

Known issues
============
This release has the following known issues worth noting:
* Non-compliant behavior for array indices near 2G or 4G elements.
* RegExp parser is strict and won't accept some real world RegExps which
  are technically not compliant with Ecmascript E5/E5.1 specification.
* Final mantissa bit rounding issues in the internal number-to-string
  conversion.
* On FreeBSD 10.x (at least 10.1 and 10.2): Clang with ``-m32`` generates
  incorrect code for union assignments needed by Duktape's 8-byte packed
  value encoding (see
  https://github.com/svaarala/duktape/blo … aliasing.c).
  The issue can be detected by defining ``DUK_OPT_SELF_TESTS``.  A workaround
  is to avoid packed types in this case by defining ``DUK_OPT_NO_PACKED_TVAL``.

Log message:
Add libduktape, an MIT-licensed Javascript engine - this is the library
which can be embedded in other C programs.

	Duktape is an embeddable Ecmascript E5/E5.1 engine with a focus on
	portability and compact footprint.  By integrating Duktape into your
	C/C++ program you can easily extend its functionality through
	scripting.  You can also build the main control flow of your program
	in Ecmascript and use fast C code functions to do heavy lifting.

	The terms Ecmascript and Javascript are often considered more or less
	equivalent, although Javascript and its variants are technically just
	one environment where the Ecmascript language is used.  The line
	between the two is not very clear in practice:  even non-browser
	Ecmascript environments often provide some browser-specific built-ins.
	Duktape is no exception, and provides the commonly used print() and
	alert() built-ins.  Even so, we use the term Ecmascript throughout to
	refer to the language implemented by Duktape.