Be safer about iterable.js property descriptors

Build function.js on top of object.js infra

This allows us to be a little safer about our property descriptors.

Swap some things between value.js and object.js

- Property Descriptor record functions → object.js. Leaving
  `completePropertyDescriptor` in value.js for now, since it does not
  expect specifically a property descriptor record.

- `toPropertyKey` → value.js

Refactor object.js not to depend on function.js

This unfortunately requires a literal re·implementation of
`Object.assign`, but it’s otherwise worth it.

This commit also adds `defineOwnDataProperty` and
`defineOwnNonenumerableDataProperty` for convenience.

Make getOwnPropertyDescriptor(s) safer

Return proxied property descriptor records from these functions (which
inherit from null) to prevent weirdness should somebody try to modify
`Object.prototype`.

De‐classify property descriptors; move to value.js

The conversion to and from property descriptors doesn’t only look at
own properties, so it is convenient to create ones with a null
prototype (to prevent attempts at hacking into, e·g,
`Object.prototype`). This means the existing class‐based approach
isn’t viable and a more functional approach is better.

Many of the property descriptor functions explicitly handle undefined,
so treating them as values and not objects makes sense, even if some
(`completePropertyDescriptor`, `toPropertyDescriptor`) throw if their
argument is not an object.

Add createProxyConstructor to function.js

Refactor some functions in function.js to simplify

Make create⸺Function setup more flexible

- Don’t assign the `.prototype` if it doesn’t already exist. (Note: It
  is not possible for a constructor to lack a `.prototype` without
  proxying.)

- Don’t change the prototype of a function which has already had its
  prototype changed.

Move toFunctionName into value.js

This is a value coercion function akin to `toLength` or `toIndex`.

Move numeric constants into value.js

This follows the pattern of declaring symbol constants here so they are
accessible everywhere.

Move isConcatSpreadable[Object] into object.js

This is an object test which is not *necessarily* about collections.

Simplify implementation of defineOwnProperties

There was no reason to create a custom iterable here; just iterate the
splat array manually.

Drop dependency on object.js from symbol.js

This is only a loadtime dependency and not necessary.

Move arraylike functions into object.js

Arraylikes are treated as objects, even when they aren’t literally
objects (e·g strings). `isArraylikeObject` notably checks for both.

Move isArrayIndexString into string.js

…and add some missing tests for isIntegerIndexString.

Move string functions from value.js to string.js

These actually make more sense here!

Move isIntegerIndexString into value.js

While potentially relevant to collections, this function is actually
about classifying types of value.

Test constructability, name, length in numeric.js

Rename Ascii‐related functions in string.js

Treating Ascii as a pronouncable acronym, not an unpronouncable one.

Rename scalarValueString → toScalarValueString

Also update the implementation to use the new `String::toWellFormed`
method.

Test constructability, name, length in string.js

Refactor object.js to use createArrowFunction

Redo create⸺Function A·P·I in function.js

`createCallableFunction` and `createIllegalConstructor` are now joined
by a `createArrowFunction`, and all three have extremely similar
interfaces. Further refactoring is probably necessary elsewhere in the
codebase to make use of these changes.

Move arraylike & index functions → values.js

Lengths and indices are properly kinds of values, not kinds of
collections, and this enables their use much earlier in the dependency
chain.

Test constructability, name, length in iterable.js

Improve object.js a·p·i

- Add tests for functions which were formerly just re·exports of
  standard library functions.

- Test constructibility, name, and length for all exported functions.

- Replace `isFrozenObject` and `isSealedObject` with `isUnfrozenObject`
  and `isUnsealedObject`, as the former versions return _true_, not
  _false_, when provided with a non·object argument.

- Revise `setPrototype` to have better behaviours than the Ecmascript
  implementation when provided with a non·object argument.

Cast to primitive when creating function names

This matches the behaviour of `toPropertyKey`, which is a soft spec
prerequisite (`SetFunctionName` takes a property key argument).

Define names for LazyLoader getters & setters

This commit also fixes some of the `LazyLoader` tests.

Cast to function name in createCallableFunction

This requires moving the definition of `toFunctionName` inside the same
closure as `createCallableFunction` to ensure that it is defined before
`createCallableFunction` is called (e·g when defining
`ordinaryHasInstance`).

Test createCallableFunction names and lengths

Test function lengths in {value∣function∣symbol}.js

Add toFunctionName to function.js

Add symbolToString and symbolValue to symbol.js

Rename make⸺ to create⸺ in function.js

“make⸺” names are used in the Ecmascript specification to describe
in‐place modifications. These functions return new values, so “create”
is more appropriate.

Create symbol.js module with getSymbolDescription

Add makeIllegalConstructor to functions.js

Test function.js non·constructor constructability

Ensure each function in function.js has proper name

Also provides a wrapper for `constructor` for parity even though this
isn’t strictly required, and simplifies the implementation of
`isConstructor` to make use of `completesNormally`.

Add completesNormally to function.js

This is a convenience function which returns true if calling the
argument results in a normal completion (i·e not a throw), and false
otherwise.

Use strict asserts in function.test.js

Also test to ensure that getters and setters are not constructable.

Test value.js non·constructor constructability

Ensure each function in value.js has correct name

This requires making `sameValue` a wrapper of `Object.is` instead of
literally the same function.

Use strict asserts in value.test.js

Add iterator function builders; use in string.js

This commit adds a number of new `⸺IteratorFunction` functions in a
new `iterable.js` module, for building “iterator functions” from
various kinds of iterable object (as well as generator functions, which
are not themselves iterable). These functions are useful
metaprogramming tools for creating iterators akin to those produced by
the native Ecmascript builtins like `Array::values` or `Map::entries`
when starting from an already‐iterable base value but needing to map it
somehow.

The existing functions `codeUnits`, `codepoints`, and `scalarValues`
already fell into this category and have been refactored to make use of
the new technique.

Add buffer getters and setters to binary.js

These are rough equivalents to the `DataView` methods, but can be
called with any kind of array buffer or array buffer view. Internally,
they (weakly) remember a `DataView` instance for each buffer and use
that for accessing values (to ensure correct endianness behaviour).

Add arrayBufferSlice to binary.js

Support SharedArrayBuffer; drop isDataView

- `SharedArrayBuffer` counts as an array buffer; use
  `isArrayBuffer($) && !isSharedArrayBuffer($)` to detect only
  non‐shared buffers.

- `isDataView` is no longer supported as a separate function; use
  `isArrayBufferView($) && !isTypedArray($)` to detect data views.

Apply various minor updates to binary.js

Rename is⸺ to is⸺Object in object.js

Apply various minor formatting changes

Rename to{I∣Ui}ntN to to{S∣Uns}ignedIntegralNumeric

“int·N” and “u·int·N” are not really ♓🌟 Piscēs terms.

Fix linting errors in string.*

Export welknown symbols from value.js and use them

This commit changes function.js to depend on value.js and not the other
way around.

Use === more frequently in binary.js

The convention is to use `===` in situations where type·casting is
known not occur.

Add various is⸺ functions to binary.js

Add isArrayBufferView & toArrayBuffer to binary.js

This also removes a previous less‐than‐ideal dependency on `instanceof`
when converting arguments to array buffers for base⸺ conversions.

Fix permissions of binary.test.js

For some reason this file had execute permissions, which are wholly
unnecessary.

Make base32 handling less forgiving

Ordinarily, one only encounters base32 strings of length 0, 2, 4, 5, or
7 characters (mod 8). If it is of length 3 or 6, the final character is
in the middle of an incomplete byte. As with length 1, this should
probably throw an error, as the other alternative is to entirely ignore
the character.

(It already did throw an error before this change, but
unintentionally.)

Add ::flags override to Matcher

Otherwise this code will break if new flags are added but not supported
by ♓🌟 Piscēs.

Use strict equals in Matcher constraint tests

Otherwise Deno will see Matcher is a RegExp and cast to a string.

Add base32 support to binary.js

Includes both the RFC base32 definition and the “W·R·M·G” definition by
Douglas Crockford.

Add base16 support to binary.js

Just iterating over the bytes and doing `$.toString(16).toUpperCase()`
or `parseInt($, 16)` might actually be faster, but I kind of like using
an actual algorithm to ensure parity with base64 ⁊·c processing.

Fix base64 implementation

I believe that the old implementation was just wrong, and it simply
wasn’t caught because Deno’s `assertEquals` doesn’t actually know what
to do with raw buffers. Wrapping them to build typed arrays creates
working tests, and this implementation matches observed behaviour with
`atob` and `btoa`.

Remove irregular whitespace

Polish object.js a little

Polish binary.js a little bit.

Internal functions now have some code documentation, and the runtime
dependency on arrays being iterable (for splatting arguments) was
removed.

Rename base64.js to binary.js; reorganize contents

`atob` and `btoa` now have the much clearer names `base64Binary` and
`base64String`; filename‐safe equivalents have been added.

The intention is to add the base16 and base32 formats from R·F·C 3548
as well, although that work is still forthcoming.

Add to⸺Notation functions to numeric.js

The default Number::toString method provides a result which is
difficult to parse. Number::toExponential and Number::toFixed are
better; they are now provided via toExponentialNotation and
toFixedDecimalNotation. Support for big·ints has been added as well.

toIntegerOrInfinity 🔜 toIntegralNumberOrInfinity

This new name is clearer, especially as this function now accepts
big·int arguments.

Add toIntegralNumber to numeric.js

Also allow big·int arguments in toIntegerOrInfinity.

Add POSITIVE_ZERO and NEGATIVE_ZERO to numeric.js

Provide fake external constructor for Matcher

Classes which depend on identity for behaviours should not be exposed
because this inheritance can be modified at runtime. This commit
provides a fake Matcher constructor which simply calls the real one.

This has a side‐effect of reducing the amount of prototype modification
which this class setup entailed, at the cost of needing to manually
redefine all the properties from the internal Matcher constructor
prototype onto the external one.

Pass exec result to constraint in Matcher

Add support for constraints to Matcher

Make toIntN & toUintN more accommodating

These used to not handle non‐integers well, and now do gracefully.

Treat object function args more consistently

Functions like getOwnPropertyKeys now do not require that their
arguments are objects, but *do* require that they are not null or
undefined. Similarly, toObject now throws for null and undefined
values, rather than returning an empty object. Use `toObject($ ?? {})`
if you need the old behaviour.

Add toString to string.js

Also properly casts some arguments of string functions to strings.

Add toIntegerOrInfinity to numeric.js

Add LazyLoader class

Add isArraylikeObject

Also renames lengthOfArrayLike 🔜 lengthOfArraylike.

Update README

Refactor base64; remove runtime dependencies

Refactor iri; remove runtime dependencies

Add Matcher class for whole‐string matching

Add arraylike functions and collection unit tests

Add string functions and unit tests

Add numeric functions and unit tests

Remove dependencies of function.js; add tests

- No longer depends on mutable runtime bindings or other modules

- Unit tests for all function exports

Split some object code into value and unit test

Also adds tests for module exports.

Basic functions for object & function manipulation

Add string functions

L·E·I·R·I support

More comprehensive support for RFC 3986 & RFC 3987

PropertyDescriptor and frozenCopy

toPrimitive and toPropertyKey

Initial codes

Most of this was taken from الرشآء.