WIP: bootstrap and partial real Solana watcher implementation
This commit is contained in:
File diff suppressed because one or more lines are too long
@@ -0,0 +1 @@
|
||||
export { _ as default } from "../esm/_set_prototype_of.js";
|
||||
@@ -0,0 +1 @@
|
||||
export { _ as default } from "../esm/_class_private_field_set.js";
|
||||
@@ -0,0 +1,280 @@
|
||||
import { Writer } from './buffer-writer'
|
||||
|
||||
const enum code {
|
||||
startup = 0x70,
|
||||
query = 0x51,
|
||||
parse = 0x50,
|
||||
bind = 0x42,
|
||||
execute = 0x45,
|
||||
flush = 0x48,
|
||||
sync = 0x53,
|
||||
end = 0x58,
|
||||
close = 0x43,
|
||||
describe = 0x44,
|
||||
copyFromChunk = 0x64,
|
||||
copyDone = 0x63,
|
||||
copyFail = 0x66,
|
||||
}
|
||||
|
||||
const writer = new Writer()
|
||||
|
||||
const startup = (opts: Record<string, string>): Buffer => {
|
||||
// protocol version
|
||||
writer.addInt16(3).addInt16(0)
|
||||
for (const key of Object.keys(opts)) {
|
||||
writer.addCString(key).addCString(opts[key])
|
||||
}
|
||||
|
||||
writer.addCString('client_encoding').addCString('UTF8')
|
||||
|
||||
const bodyBuffer = writer.addCString('').flush()
|
||||
// this message is sent without a code
|
||||
|
||||
const length = bodyBuffer.length + 4
|
||||
|
||||
return new Writer().addInt32(length).add(bodyBuffer).flush()
|
||||
}
|
||||
|
||||
const requestSsl = (): Buffer => {
|
||||
const response = Buffer.allocUnsafe(8)
|
||||
response.writeInt32BE(8, 0)
|
||||
response.writeInt32BE(80877103, 4)
|
||||
return response
|
||||
}
|
||||
|
||||
const password = (password: string): Buffer => {
|
||||
return writer.addCString(password).flush(code.startup)
|
||||
}
|
||||
|
||||
const sendSASLInitialResponseMessage = function (mechanism: string, initialResponse: string): Buffer {
|
||||
// 0x70 = 'p'
|
||||
writer.addCString(mechanism).addInt32PrefixedString(initialResponse)
|
||||
|
||||
return writer.flush(code.startup)
|
||||
}
|
||||
|
||||
const sendSCRAMClientFinalMessage = function (additionalData: string): Buffer {
|
||||
return writer.addString(additionalData).flush(code.startup)
|
||||
}
|
||||
|
||||
const query = (text: string): Buffer => {
|
||||
return writer.addCString(text).flush(code.query)
|
||||
}
|
||||
|
||||
type ParseOpts = {
|
||||
name?: string
|
||||
types?: number[]
|
||||
text: string
|
||||
}
|
||||
|
||||
const emptyArray: any[] = []
|
||||
|
||||
const parse = (query: ParseOpts): Buffer => {
|
||||
// expect something like this:
|
||||
// { name: 'queryName',
|
||||
// text: 'select * from blah',
|
||||
// types: ['int8', 'bool'] }
|
||||
|
||||
// normalize missing query names to allow for null
|
||||
const name = query.name || ''
|
||||
if (name.length > 63) {
|
||||
console.error('Warning! Postgres only supports 63 characters for query names.')
|
||||
console.error('You supplied %s (%s)', name, name.length)
|
||||
console.error('This can cause conflicts and silent errors executing queries')
|
||||
}
|
||||
|
||||
const types = query.types || emptyArray
|
||||
|
||||
const len = types.length
|
||||
|
||||
const buffer = writer
|
||||
.addCString(name) // name of query
|
||||
.addCString(query.text) // actual query text
|
||||
.addInt16(len)
|
||||
|
||||
for (let i = 0; i < len; i++) {
|
||||
buffer.addInt32(types[i])
|
||||
}
|
||||
|
||||
return writer.flush(code.parse)
|
||||
}
|
||||
|
||||
type ValueMapper = (param: any, index: number) => any
|
||||
|
||||
type BindOpts = {
|
||||
portal?: string
|
||||
binary?: boolean
|
||||
statement?: string
|
||||
values?: any[]
|
||||
// optional map from JS value to postgres value per parameter
|
||||
valueMapper?: ValueMapper
|
||||
}
|
||||
|
||||
const paramWriter = new Writer()
|
||||
|
||||
// make this a const enum so typescript will inline the value
|
||||
const enum ParamType {
|
||||
STRING = 0,
|
||||
BINARY = 1,
|
||||
}
|
||||
|
||||
const writeValues = function (values: any[], valueMapper?: ValueMapper): void {
|
||||
for (let i = 0; i < values.length; i++) {
|
||||
const mappedVal = valueMapper ? valueMapper(values[i], i) : values[i]
|
||||
if (mappedVal == null) {
|
||||
// add the param type (string) to the writer
|
||||
writer.addInt16(ParamType.STRING)
|
||||
// write -1 to the param writer to indicate null
|
||||
paramWriter.addInt32(-1)
|
||||
} else if (mappedVal instanceof Buffer) {
|
||||
// add the param type (binary) to the writer
|
||||
writer.addInt16(ParamType.BINARY)
|
||||
// add the buffer to the param writer
|
||||
paramWriter.addInt32(mappedVal.length)
|
||||
paramWriter.add(mappedVal)
|
||||
} else {
|
||||
// add the param type (string) to the writer
|
||||
writer.addInt16(ParamType.STRING)
|
||||
// length prefix + UTF-8 bytes in one pass (Buffer.byteLength computed once)
|
||||
paramWriter.addInt32PrefixedString(mappedVal)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const bind = (config: BindOpts = {}): Buffer => {
|
||||
// normalize config
|
||||
const portal = config.portal || ''
|
||||
const statement = config.statement || ''
|
||||
const binary = config.binary || false
|
||||
const values = config.values || emptyArray
|
||||
const len = values.length
|
||||
|
||||
writer.addCString(portal).addCString(statement)
|
||||
writer.addInt16(len)
|
||||
|
||||
try {
|
||||
writeValues(values, config.valueMapper)
|
||||
} catch (err) {
|
||||
writer.clear()
|
||||
paramWriter.clear()
|
||||
throw err
|
||||
}
|
||||
|
||||
writer.addInt16(len)
|
||||
writer.add(paramWriter.flush())
|
||||
|
||||
// all results use the same format code
|
||||
writer.addInt16(1)
|
||||
// format code
|
||||
writer.addInt16(binary ? ParamType.BINARY : ParamType.STRING)
|
||||
return writer.flush(code.bind)
|
||||
}
|
||||
|
||||
type ExecOpts = {
|
||||
portal?: string
|
||||
rows?: number
|
||||
}
|
||||
|
||||
const emptyExecute = Buffer.from([code.execute, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00])
|
||||
|
||||
const execute = (config?: ExecOpts): Buffer => {
|
||||
// this is the happy path for most queries
|
||||
if (!config || (!config.portal && !config.rows)) {
|
||||
return emptyExecute
|
||||
}
|
||||
|
||||
const portal = config.portal || ''
|
||||
const rows = config.rows || 0
|
||||
|
||||
const portalLength = Buffer.byteLength(portal)
|
||||
const len = 4 + portalLength + 1 + 4
|
||||
// one extra bit for code
|
||||
const buff = Buffer.allocUnsafe(1 + len)
|
||||
buff[0] = code.execute
|
||||
buff.writeInt32BE(len, 1)
|
||||
buff.write(portal, 5, 'utf-8')
|
||||
buff[portalLength + 5] = 0 // null terminate portal cString
|
||||
buff.writeUInt32BE(rows, buff.length - 4)
|
||||
return buff
|
||||
}
|
||||
|
||||
const cancel = (processID: number, secretKey: number): Buffer => {
|
||||
const buffer = Buffer.allocUnsafe(16)
|
||||
buffer.writeInt32BE(16, 0)
|
||||
buffer.writeInt16BE(1234, 4)
|
||||
buffer.writeInt16BE(5678, 6)
|
||||
buffer.writeInt32BE(processID, 8)
|
||||
buffer.writeInt32BE(secretKey, 12)
|
||||
return buffer
|
||||
}
|
||||
|
||||
type PortalOpts = {
|
||||
type: 'S' | 'P'
|
||||
name?: string
|
||||
}
|
||||
|
||||
const cstringMessage = (code: code, string: string): Buffer => {
|
||||
const stringLen = Buffer.byteLength(string)
|
||||
const len = 4 + stringLen + 1
|
||||
// one extra bit for code
|
||||
const buffer = Buffer.allocUnsafe(1 + len)
|
||||
buffer[0] = code
|
||||
buffer.writeInt32BE(len, 1)
|
||||
buffer.write(string, 5, 'utf-8')
|
||||
buffer[len] = 0 // null terminate cString
|
||||
return buffer
|
||||
}
|
||||
|
||||
const emptyDescribePortal = writer.addCString('P').flush(code.describe)
|
||||
const emptyDescribeStatement = writer.addCString('S').flush(code.describe)
|
||||
|
||||
const describe = (msg: PortalOpts): Buffer => {
|
||||
return msg.name
|
||||
? cstringMessage(code.describe, `${msg.type}${msg.name || ''}`)
|
||||
: msg.type === 'P'
|
||||
? emptyDescribePortal
|
||||
: emptyDescribeStatement
|
||||
}
|
||||
|
||||
const close = (msg: PortalOpts): Buffer => {
|
||||
const text = `${msg.type}${msg.name || ''}`
|
||||
return cstringMessage(code.close, text)
|
||||
}
|
||||
|
||||
const copyData = (chunk: Buffer): Buffer => {
|
||||
return writer.add(chunk).flush(code.copyFromChunk)
|
||||
}
|
||||
|
||||
const copyFail = (message: string): Buffer => {
|
||||
return cstringMessage(code.copyFail, message)
|
||||
}
|
||||
|
||||
const codeOnlyBuffer = (code: code): Buffer => Buffer.from([code, 0x00, 0x00, 0x00, 0x04])
|
||||
|
||||
const flushBuffer = codeOnlyBuffer(code.flush)
|
||||
const syncBuffer = codeOnlyBuffer(code.sync)
|
||||
const endBuffer = codeOnlyBuffer(code.end)
|
||||
const copyDoneBuffer = codeOnlyBuffer(code.copyDone)
|
||||
|
||||
const serialize = {
|
||||
startup,
|
||||
password,
|
||||
requestSsl,
|
||||
sendSASLInitialResponseMessage,
|
||||
sendSCRAMClientFinalMessage,
|
||||
query,
|
||||
parse,
|
||||
bind,
|
||||
execute,
|
||||
describe,
|
||||
close,
|
||||
flush: () => flushBuffer,
|
||||
sync: () => syncBuffer,
|
||||
end: () => endBuffer,
|
||||
copyData,
|
||||
copyDone: () => copyDoneBuffer,
|
||||
copyFail,
|
||||
cancel,
|
||||
}
|
||||
|
||||
export { serialize }
|
||||
@@ -0,0 +1,4 @@
|
||||
function _OverloadYield(e, d) {
|
||||
this.v = e, this.k = d;
|
||||
}
|
||||
export { _OverloadYield as default };
|
||||
@@ -0,0 +1,133 @@
|
||||
/*! *****************************************************************************
|
||||
Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
|
||||
this file except in compliance with the License. You may obtain a copy of the
|
||||
License at http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
|
||||
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
|
||||
MERCHANTABILITY OR NON-INFRINGEMENT.
|
||||
|
||||
See the Apache Version 2.0 License for specific language governing permissions
|
||||
and limitations under the License.
|
||||
***************************************************************************** */
|
||||
|
||||
|
||||
/// <reference lib="es2015.symbol" />
|
||||
/// <reference lib="es2015.symbol.wellknown" />
|
||||
|
||||
interface SharedArrayBuffer {
|
||||
/**
|
||||
* Read-only. The length of the ArrayBuffer (in bytes).
|
||||
*/
|
||||
readonly byteLength: number;
|
||||
|
||||
/**
|
||||
* Returns a section of an SharedArrayBuffer.
|
||||
*/
|
||||
slice(begin?: number, end?: number): SharedArrayBuffer;
|
||||
readonly [Symbol.toStringTag]: "SharedArrayBuffer";
|
||||
}
|
||||
|
||||
interface SharedArrayBufferConstructor {
|
||||
readonly prototype: SharedArrayBuffer;
|
||||
new (byteLength?: number): SharedArrayBuffer;
|
||||
readonly [Symbol.species]: SharedArrayBufferConstructor;
|
||||
}
|
||||
declare var SharedArrayBuffer: SharedArrayBufferConstructor;
|
||||
|
||||
interface ArrayBufferTypes {
|
||||
SharedArrayBuffer: SharedArrayBuffer;
|
||||
}
|
||||
|
||||
interface Atomics {
|
||||
/**
|
||||
* Adds a value to the value at the given position in the array, returning the original value.
|
||||
* Until this atomic operation completes, any other read or write operation against the array
|
||||
* will block.
|
||||
*/
|
||||
add(typedArray: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>, index: number, value: number): number;
|
||||
|
||||
/**
|
||||
* Stores the bitwise AND of a value with the value at the given position in the array,
|
||||
* returning the original value. Until this atomic operation completes, any other read or
|
||||
* write operation against the array will block.
|
||||
*/
|
||||
and(typedArray: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>, index: number, value: number): number;
|
||||
|
||||
/**
|
||||
* Replaces the value at the given position in the array if the original value equals the given
|
||||
* expected value, returning the original value. Until this atomic operation completes, any
|
||||
* other read or write operation against the array will block.
|
||||
*/
|
||||
compareExchange(typedArray: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>, index: number, expectedValue: number, replacementValue: number): number;
|
||||
|
||||
/**
|
||||
* Replaces the value at the given position in the array, returning the original value. Until
|
||||
* this atomic operation completes, any other read or write operation against the array will
|
||||
* block.
|
||||
*/
|
||||
exchange(typedArray: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>, index: number, value: number): number;
|
||||
|
||||
/**
|
||||
* Returns a value indicating whether high-performance algorithms can use atomic operations
|
||||
* (`true`) or must use locks (`false`) for the given number of bytes-per-element of a typed
|
||||
* array.
|
||||
*/
|
||||
isLockFree(size: number): boolean;
|
||||
|
||||
/**
|
||||
* Returns the value at the given position in the array. Until this atomic operation completes,
|
||||
* any other read or write operation against the array will block.
|
||||
*/
|
||||
load(typedArray: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>, index: number): number;
|
||||
|
||||
/**
|
||||
* Stores the bitwise OR of a value with the value at the given position in the array,
|
||||
* returning the original value. Until this atomic operation completes, any other read or write
|
||||
* operation against the array will block.
|
||||
*/
|
||||
or(typedArray: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>, index: number, value: number): number;
|
||||
|
||||
/**
|
||||
* Stores a value at the given position in the array, returning the new value. Until this
|
||||
* atomic operation completes, any other read or write operation against the array will block.
|
||||
*/
|
||||
store(typedArray: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>, index: number, value: number): number;
|
||||
|
||||
/**
|
||||
* Subtracts a value from the value at the given position in the array, returning the original
|
||||
* value. Until this atomic operation completes, any other read or write operation against the
|
||||
* array will block.
|
||||
*/
|
||||
sub(typedArray: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>, index: number, value: number): number;
|
||||
|
||||
/**
|
||||
* If the value at the given position in the array is equal to the provided value, the current
|
||||
* agent is put to sleep causing execution to suspend until the timeout expires (returning
|
||||
* `"timed-out"`) or until the agent is awoken (returning `"ok"`); otherwise, returns
|
||||
* `"not-equal"`.
|
||||
*/
|
||||
wait(typedArray: Int32Array<ArrayBufferLike>, index: number, value: number, timeout?: number): "ok" | "not-equal" | "timed-out";
|
||||
|
||||
/**
|
||||
* Wakes up sleeping agents that are waiting on the given index of the array, returning the
|
||||
* number of agents that were awoken.
|
||||
* @param typedArray A shared Int32Array<ArrayBufferLike>.
|
||||
* @param index The position in the typedArray to wake up on.
|
||||
* @param count The number of sleeping agents to notify. Defaults to +Infinity.
|
||||
*/
|
||||
notify(typedArray: Int32Array<ArrayBufferLike>, index: number, count?: number): number;
|
||||
|
||||
/**
|
||||
* Stores the bitwise XOR of a value with the value at the given position in the array,
|
||||
* returning the original value. Until this atomic operation completes, any other read or write
|
||||
* operation against the array will block.
|
||||
*/
|
||||
xor(typedArray: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>, index: number, value: number): number;
|
||||
|
||||
readonly [Symbol.toStringTag]: "Atomics";
|
||||
}
|
||||
|
||||
declare var Atomics: Atomics;
|
||||
@@ -0,0 +1,6 @@
|
||||
import cjsModule from '../index.js'
|
||||
|
||||
export const configure = cjsModule.configure
|
||||
|
||||
export const stringify = cjsModule
|
||||
export default cjsModule
|
||||
@@ -0,0 +1,236 @@
|
||||
var _typeof = require("./typeof.js")["default"];
|
||||
var setFunctionName = require("./setFunctionName.js");
|
||||
var toPropertyKey = require("./toPropertyKey.js");
|
||||
function old_createMetadataMethodsForProperty(e, t, a, r) {
|
||||
return {
|
||||
getMetadata: function getMetadata(o) {
|
||||
old_assertNotFinished(r, "getMetadata"), old_assertMetadataKey(o);
|
||||
var i = e[o];
|
||||
if (void 0 !== i) if (1 === t) {
|
||||
var n = i["public"];
|
||||
if (void 0 !== n) return n[a];
|
||||
} else if (2 === t) {
|
||||
var l = i["private"];
|
||||
if (void 0 !== l) return l.get(a);
|
||||
} else if (Object.hasOwnProperty.call(i, "constructor")) return i.constructor;
|
||||
},
|
||||
setMetadata: function setMetadata(o, i) {
|
||||
old_assertNotFinished(r, "setMetadata"), old_assertMetadataKey(o);
|
||||
var n = e[o];
|
||||
if (void 0 === n && (n = e[o] = {}), 1 === t) {
|
||||
var l = n["public"];
|
||||
void 0 === l && (l = n["public"] = {}), l[a] = i;
|
||||
} else if (2 === t) {
|
||||
var s = n.priv;
|
||||
void 0 === s && (s = n["private"] = new Map()), s.set(a, i);
|
||||
} else n.constructor = i;
|
||||
}
|
||||
};
|
||||
}
|
||||
function old_convertMetadataMapToFinal(e, t) {
|
||||
var a = e[Symbol.metadata || Symbol["for"]("Symbol.metadata")],
|
||||
r = Object.getOwnPropertySymbols(t);
|
||||
if (0 !== r.length) {
|
||||
for (var o = 0; o < r.length; o++) {
|
||||
var i = r[o],
|
||||
n = t[i],
|
||||
l = a ? a[i] : null,
|
||||
s = n["public"],
|
||||
c = l ? l["public"] : null;
|
||||
s && c && Object.setPrototypeOf(s, c);
|
||||
var d = n["private"];
|
||||
if (d) {
|
||||
var u = Array.from(d.values()),
|
||||
f = l ? l["private"] : null;
|
||||
f && (u = u.concat(f)), n["private"] = u;
|
||||
}
|
||||
l && Object.setPrototypeOf(n, l);
|
||||
}
|
||||
a && Object.setPrototypeOf(t, a), e[Symbol.metadata || Symbol["for"]("Symbol.metadata")] = t;
|
||||
}
|
||||
}
|
||||
function old_createAddInitializerMethod(e, t) {
|
||||
return function (a) {
|
||||
old_assertNotFinished(t, "addInitializer"), old_assertCallable(a, "An initializer"), e.push(a);
|
||||
};
|
||||
}
|
||||
function old_memberDec(e, t, a, r, o, i, n, l, s) {
|
||||
var c;
|
||||
switch (i) {
|
||||
case 1:
|
||||
c = "accessor";
|
||||
break;
|
||||
case 2:
|
||||
c = "method";
|
||||
break;
|
||||
case 3:
|
||||
c = "getter";
|
||||
break;
|
||||
case 4:
|
||||
c = "setter";
|
||||
break;
|
||||
default:
|
||||
c = "field";
|
||||
}
|
||||
var d,
|
||||
u,
|
||||
f = {
|
||||
kind: c,
|
||||
name: l ? "#" + t : toPropertyKey(t),
|
||||
isStatic: n,
|
||||
isPrivate: l
|
||||
},
|
||||
p = {
|
||||
v: !1
|
||||
};
|
||||
if (0 !== i && (f.addInitializer = old_createAddInitializerMethod(o, p)), l) {
|
||||
d = 2, u = Symbol(t);
|
||||
var v = {};
|
||||
0 === i ? (v.get = a.get, v.set = a.set) : 2 === i ? v.get = function () {
|
||||
return a.value;
|
||||
} : (1 !== i && 3 !== i || (v.get = function () {
|
||||
return a.get.call(this);
|
||||
}), 1 !== i && 4 !== i || (v.set = function (e) {
|
||||
a.set.call(this, e);
|
||||
})), f.access = v;
|
||||
} else d = 1, u = t;
|
||||
try {
|
||||
return e(s, Object.assign(f, old_createMetadataMethodsForProperty(r, d, u, p)));
|
||||
} finally {
|
||||
p.v = !0;
|
||||
}
|
||||
}
|
||||
function old_assertNotFinished(e, t) {
|
||||
if (e.v) throw Error("attempted to call " + t + " after decoration was finished");
|
||||
}
|
||||
function old_assertMetadataKey(e) {
|
||||
if ("symbol" != _typeof(e)) throw new TypeError("Metadata keys must be symbols, received: " + e);
|
||||
}
|
||||
function old_assertCallable(e, t) {
|
||||
if ("function" != typeof e) throw new TypeError(t + " must be a function");
|
||||
}
|
||||
function old_assertValidReturnValue(e, t) {
|
||||
var a = _typeof(t);
|
||||
if (1 === e) {
|
||||
if ("object" !== a || null === t) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
|
||||
void 0 !== t.get && old_assertCallable(t.get, "accessor.get"), void 0 !== t.set && old_assertCallable(t.set, "accessor.set"), void 0 !== t.init && old_assertCallable(t.init, "accessor.init"), void 0 !== t.initializer && old_assertCallable(t.initializer, "accessor.initializer");
|
||||
} else if ("function" !== a) throw new TypeError((0 === e ? "field" : 10 === e ? "class" : "method") + " decorators must return a function or void 0");
|
||||
}
|
||||
function old_getInit(e) {
|
||||
var t;
|
||||
return null == (t = e.init) && (t = e.initializer) && void 0 !== console && console.warn(".initializer has been renamed to .init as of March 2022"), t;
|
||||
}
|
||||
function old_applyMemberDec(e, t, a, r, o, i, n, l, s) {
|
||||
var c,
|
||||
d,
|
||||
u,
|
||||
f,
|
||||
p,
|
||||
v,
|
||||
y,
|
||||
h = a[0];
|
||||
if (n ? (0 === o || 1 === o ? (c = {
|
||||
get: a[3],
|
||||
set: a[4]
|
||||
}, u = "get") : 3 === o ? (c = {
|
||||
get: a[3]
|
||||
}, u = "get") : 4 === o ? (c = {
|
||||
set: a[3]
|
||||
}, u = "set") : c = {
|
||||
value: a[3]
|
||||
}, 0 !== o && (1 === o && setFunctionName(a[4], "#" + r, "set"), setFunctionName(a[3], "#" + r, u))) : 0 !== o && (c = Object.getOwnPropertyDescriptor(t, r)), 1 === o ? f = {
|
||||
get: c.get,
|
||||
set: c.set
|
||||
} : 2 === o ? f = c.value : 3 === o ? f = c.get : 4 === o && (f = c.set), "function" == typeof h) void 0 !== (p = old_memberDec(h, r, c, l, s, o, i, n, f)) && (old_assertValidReturnValue(o, p), 0 === o ? d = p : 1 === o ? (d = old_getInit(p), v = p.get || f.get, y = p.set || f.set, f = {
|
||||
get: v,
|
||||
set: y
|
||||
}) : f = p);else for (var m = h.length - 1; m >= 0; m--) {
|
||||
var b;
|
||||
void 0 !== (p = old_memberDec(h[m], r, c, l, s, o, i, n, f)) && (old_assertValidReturnValue(o, p), 0 === o ? b = p : 1 === o ? (b = old_getInit(p), v = p.get || f.get, y = p.set || f.set, f = {
|
||||
get: v,
|
||||
set: y
|
||||
}) : f = p, void 0 !== b && (void 0 === d ? d = b : "function" == typeof d ? d = [d, b] : d.push(b)));
|
||||
}
|
||||
if (0 === o || 1 === o) {
|
||||
if (void 0 === d) d = function d(e, t) {
|
||||
return t;
|
||||
};else if ("function" != typeof d) {
|
||||
var g = d;
|
||||
d = function d(e, t) {
|
||||
for (var a = t, r = 0; r < g.length; r++) a = g[r].call(e, a);
|
||||
return a;
|
||||
};
|
||||
} else {
|
||||
var _ = d;
|
||||
d = function d(e, t) {
|
||||
return _.call(e, t);
|
||||
};
|
||||
}
|
||||
e.push(d);
|
||||
}
|
||||
0 !== o && (1 === o ? (c.get = f.get, c.set = f.set) : 2 === o ? c.value = f : 3 === o ? c.get = f : 4 === o && (c.set = f), n ? 1 === o ? (e.push(function (e, t) {
|
||||
return f.get.call(e, t);
|
||||
}), e.push(function (e, t) {
|
||||
return f.set.call(e, t);
|
||||
})) : 2 === o ? e.push(f) : e.push(function (e, t) {
|
||||
return f.call(e, t);
|
||||
}) : Object.defineProperty(t, r, c));
|
||||
}
|
||||
function old_applyMemberDecs(e, t, a, r, o) {
|
||||
for (var i, n, l = new Map(), s = new Map(), c = 0; c < o.length; c++) {
|
||||
var d = o[c];
|
||||
if (Array.isArray(d)) {
|
||||
var u,
|
||||
f,
|
||||
p,
|
||||
v = d[1],
|
||||
y = d[2],
|
||||
h = d.length > 3,
|
||||
m = v >= 5;
|
||||
if (m ? (u = t, f = r, 0 != (v -= 5) && (p = n = n || [])) : (u = t.prototype, f = a, 0 !== v && (p = i = i || [])), 0 !== v && !h) {
|
||||
var b = m ? s : l,
|
||||
g = b.get(y) || 0;
|
||||
if (!0 === g || 3 === g && 4 !== v || 4 === g && 3 !== v) throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + y);
|
||||
!g && v > 2 ? b.set(y, v) : b.set(y, !0);
|
||||
}
|
||||
old_applyMemberDec(e, u, d, y, v, m, h, f, p);
|
||||
}
|
||||
}
|
||||
old_pushInitializers(e, i), old_pushInitializers(e, n);
|
||||
}
|
||||
function old_pushInitializers(e, t) {
|
||||
t && e.push(function (e) {
|
||||
for (var a = 0; a < t.length; a++) t[a].call(e);
|
||||
return e;
|
||||
});
|
||||
}
|
||||
function old_applyClassDecs(e, t, a, r) {
|
||||
if (r.length > 0) {
|
||||
for (var o = [], i = t, n = t.name, l = r.length - 1; l >= 0; l--) {
|
||||
var s = {
|
||||
v: !1
|
||||
};
|
||||
try {
|
||||
var c = Object.assign({
|
||||
kind: "class",
|
||||
name: n,
|
||||
addInitializer: old_createAddInitializerMethod(o, s)
|
||||
}, old_createMetadataMethodsForProperty(a, 0, n, s)),
|
||||
d = r[l](i, c);
|
||||
} finally {
|
||||
s.v = !0;
|
||||
}
|
||||
void 0 !== d && (old_assertValidReturnValue(10, d), i = d);
|
||||
}
|
||||
e.push(i, function () {
|
||||
for (var e = 0; e < o.length; e++) o[e].call(i);
|
||||
});
|
||||
}
|
||||
}
|
||||
function applyDecs(e, t, a) {
|
||||
var r = [],
|
||||
o = {},
|
||||
i = {};
|
||||
return old_applyMemberDecs(r, e, i, o, t), old_convertMetadataMapToFinal(e.prototype, i), old_applyClassDecs(r, e, o, a), old_convertMetadataMapToFinal(e, o), r;
|
||||
}
|
||||
module.exports = applyDecs, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||||
@@ -0,0 +1,2 @@
|
||||
import type { LibDefinition } from '../variable';
|
||||
export declare const es2020_full: LibDefinition;
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,78 @@
|
||||
{
|
||||
"name": "es6-promise",
|
||||
"description": "A lightweight library that provides tools for organizing asynchronous code",
|
||||
"version": "4.2.8",
|
||||
"author": "Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)",
|
||||
"browser": {
|
||||
"vertx": false
|
||||
},
|
||||
"bugs": {
|
||||
"url": "https://github.com/stefanpenner/es6-promise/issues"
|
||||
},
|
||||
"dependencies": {},
|
||||
"devDependencies": {
|
||||
"babel-plugin-transform-es2015-arrow-functions": "^6.22.0",
|
||||
"babel-plugin-transform-es2015-block-scoping": "^6.24.1",
|
||||
"babel-plugin-transform-es2015-classes": "^6.24.1",
|
||||
"babel-plugin-transform-es2015-computed-properties": "^6.24.1",
|
||||
"babel-plugin-transform-es2015-constants": "^6.1.4",
|
||||
"babel-plugin-transform-es2015-destructuring": "^6.23.0",
|
||||
"babel-plugin-transform-es2015-parameters": "^6.24.1",
|
||||
"babel-plugin-transform-es2015-shorthand-properties": "^6.24.1",
|
||||
"babel-plugin-transform-es2015-spread": "^6.22.0",
|
||||
"babel-plugin-transform-es2015-template-literals": "^6.22.0",
|
||||
"babel6-plugin-strip-class-callcheck": "^6.0.0",
|
||||
"broccoli-babel-transpiler": "^6.0.0",
|
||||
"broccoli-concat": "^3.1.0",
|
||||
"broccoli-merge-trees": "^2.0.0",
|
||||
"broccoli-rollup": "^2.0.0",
|
||||
"broccoli-stew": "^1.5.0",
|
||||
"broccoli-uglify-js": "^0.2.0",
|
||||
"broccoli-watchify": "^1.0.1",
|
||||
"ember-cli": "2.18.0-beta.2",
|
||||
"ember-cli-dependency-checker": "^2.1.0",
|
||||
"git-repo-version": "1.0.1",
|
||||
"json3": "^3.3.2",
|
||||
"mocha": "^4.0.1",
|
||||
"promises-aplus-tests-phantom": "^2.1.0-revise"
|
||||
},
|
||||
"directories": {
|
||||
"lib": "lib"
|
||||
},
|
||||
"files": [
|
||||
"dist",
|
||||
"lib",
|
||||
"es6-promise.d.ts",
|
||||
"auto.js",
|
||||
"!dist/test"
|
||||
],
|
||||
"homepage": "https://github.com/stefanpenner/es6-promise",
|
||||
"jsdelivr": "dist/es6-promise.auto.min.js",
|
||||
"keywords": [
|
||||
"futures",
|
||||
"polyfill",
|
||||
"promise",
|
||||
"promises"
|
||||
],
|
||||
"license": "MIT",
|
||||
"main": "dist/es6-promise.js",
|
||||
"namespace": "es6-promise",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git://github.com/stefanpenner/es6-promise.git"
|
||||
},
|
||||
"scripts": {
|
||||
"build": "ember build --environment production",
|
||||
"prepublishOnly": "ember build --environment production",
|
||||
"start": "ember s",
|
||||
"test": "ember test",
|
||||
"test:browser": "ember test --launch PhantomJS",
|
||||
"test:node": "ember test --launch Mocha",
|
||||
"test:server": "ember test --server"
|
||||
},
|
||||
"spm": {
|
||||
"main": "dist/es6-promise.js"
|
||||
},
|
||||
"typings": "es6-promise.d.ts",
|
||||
"unpkg": "dist/es6-promise.auto.min.js"
|
||||
}
|
||||
@@ -0,0 +1,393 @@
|
||||
/**
|
||||
* SHA3 (keccak) addons.
|
||||
*
|
||||
* * Full [NIST SP 800-185](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-185.pdf):
|
||||
* cSHAKE, KMAC, TupleHash, ParallelHash + XOF variants
|
||||
* * Reduced-round Keccak [(draft)](https://datatracker.ietf.org/doc/draft-irtf-cfrg-kangarootwelve/):
|
||||
* * 🦘 K12 aka KangarooTwelve
|
||||
* * M14 aka MarsupilamiFourteen
|
||||
* * TurboSHAKE
|
||||
* * KeccakPRG: Pseudo-random generator based on Keccak [(pdf)](https://keccak.team/files/CSF-0.1.pdf)
|
||||
* @module
|
||||
*/
|
||||
import { Keccak } from "./sha3.js";
|
||||
import { abytes, anumber, createOptHasher, createXOFer, Hash, toBytes, u32, } from "./utils.js";
|
||||
// cSHAKE && KMAC (NIST SP800-185)
|
||||
const _8n = BigInt(8);
|
||||
const _ffn = BigInt(0xff);
|
||||
// NOTE: it is safe to use bigints here, since they used only for length encoding (not actual data).
|
||||
// We use bigints in sha256 for lengths too.
|
||||
function leftEncode(n) {
|
||||
n = BigInt(n);
|
||||
const res = [Number(n & _ffn)];
|
||||
n >>= _8n;
|
||||
for (; n > 0; n >>= _8n)
|
||||
res.unshift(Number(n & _ffn));
|
||||
res.unshift(res.length);
|
||||
return new Uint8Array(res);
|
||||
}
|
||||
function rightEncode(n) {
|
||||
n = BigInt(n);
|
||||
const res = [Number(n & _ffn)];
|
||||
n >>= _8n;
|
||||
for (; n > 0; n >>= _8n)
|
||||
res.unshift(Number(n & _ffn));
|
||||
res.push(res.length);
|
||||
return new Uint8Array(res);
|
||||
}
|
||||
function chooseLen(opts, outputLen) {
|
||||
return opts.dkLen === undefined ? outputLen : opts.dkLen;
|
||||
}
|
||||
const abytesOrZero = (buf) => {
|
||||
if (buf === undefined)
|
||||
return Uint8Array.of();
|
||||
return toBytes(buf);
|
||||
};
|
||||
// NOTE: second modulo is necessary since we don't need to add padding if current element takes whole block
|
||||
const getPadding = (len, block) => new Uint8Array((block - (len % block)) % block);
|
||||
// Personalization
|
||||
function cshakePers(hash, opts = {}) {
|
||||
if (!opts || (!opts.personalization && !opts.NISTfn))
|
||||
return hash;
|
||||
// Encode and pad inplace to avoid unneccesary memory copies/slices (so we don't need to zero them later)
|
||||
// bytepad(encode_string(N) || encode_string(S), 168)
|
||||
const blockLenBytes = leftEncode(hash.blockLen);
|
||||
const fn = abytesOrZero(opts.NISTfn);
|
||||
const fnLen = leftEncode(_8n * BigInt(fn.length)); // length in bits
|
||||
const pers = abytesOrZero(opts.personalization);
|
||||
const persLen = leftEncode(_8n * BigInt(pers.length)); // length in bits
|
||||
if (!fn.length && !pers.length)
|
||||
return hash;
|
||||
hash.suffix = 0x04;
|
||||
hash.update(blockLenBytes).update(fnLen).update(fn).update(persLen).update(pers);
|
||||
let totalLen = blockLenBytes.length + fnLen.length + fn.length + persLen.length + pers.length;
|
||||
hash.update(getPadding(totalLen, hash.blockLen));
|
||||
return hash;
|
||||
}
|
||||
const gencShake = (suffix, blockLen, outputLen) => createXOFer((opts = {}) => cshakePers(new Keccak(blockLen, suffix, chooseLen(opts, outputLen), true), opts));
|
||||
export const cshake128 = /* @__PURE__ */ (() => gencShake(0x1f, 168, 128 / 8))();
|
||||
export const cshake256 = /* @__PURE__ */ (() => gencShake(0x1f, 136, 256 / 8))();
|
||||
export class KMAC extends Keccak {
|
||||
constructor(blockLen, outputLen, enableXOF, key, opts = {}) {
|
||||
super(blockLen, 0x1f, outputLen, enableXOF);
|
||||
cshakePers(this, { NISTfn: 'KMAC', personalization: opts.personalization });
|
||||
key = toBytes(key);
|
||||
abytes(key);
|
||||
// 1. newX = bytepad(encode_string(K), 168) || X || right_encode(L).
|
||||
const blockLenBytes = leftEncode(this.blockLen);
|
||||
const keyLen = leftEncode(_8n * BigInt(key.length));
|
||||
this.update(blockLenBytes).update(keyLen).update(key);
|
||||
const totalLen = blockLenBytes.length + keyLen.length + key.length;
|
||||
this.update(getPadding(totalLen, this.blockLen));
|
||||
}
|
||||
finish() {
|
||||
if (!this.finished)
|
||||
this.update(rightEncode(this.enableXOF ? 0 : _8n * BigInt(this.outputLen))); // outputLen in bits
|
||||
super.finish();
|
||||
}
|
||||
_cloneInto(to) {
|
||||
// Create new instance without calling constructor since key already in state and we don't know it.
|
||||
// Force "to" to be instance of KMAC instead of Sha3.
|
||||
if (!to) {
|
||||
to = Object.create(Object.getPrototypeOf(this), {});
|
||||
to.state = this.state.slice();
|
||||
to.blockLen = this.blockLen;
|
||||
to.state32 = u32(to.state);
|
||||
}
|
||||
return super._cloneInto(to);
|
||||
}
|
||||
clone() {
|
||||
return this._cloneInto();
|
||||
}
|
||||
}
|
||||
function genKmac(blockLen, outputLen, xof = false) {
|
||||
const kmac = (key, message, opts) => kmac.create(key, opts).update(message).digest();
|
||||
kmac.create = (key, opts = {}) => new KMAC(blockLen, chooseLen(opts, outputLen), xof, key, opts);
|
||||
return kmac;
|
||||
}
|
||||
export const kmac128 = /* @__PURE__ */ (() => genKmac(168, 128 / 8))();
|
||||
export const kmac256 = /* @__PURE__ */ (() => genKmac(136, 256 / 8))();
|
||||
export const kmac128xof = /* @__PURE__ */ (() => genKmac(168, 128 / 8, true))();
|
||||
export const kmac256xof = /* @__PURE__ */ (() => genKmac(136, 256 / 8, true))();
|
||||
// TupleHash
|
||||
// Usage: tuple(['ab', 'cd']) != tuple(['a', 'bcd'])
|
||||
export class TupleHash extends Keccak {
|
||||
constructor(blockLen, outputLen, enableXOF, opts = {}) {
|
||||
super(blockLen, 0x1f, outputLen, enableXOF);
|
||||
cshakePers(this, { NISTfn: 'TupleHash', personalization: opts.personalization });
|
||||
// Change update after cshake processed
|
||||
this.update = (data) => {
|
||||
data = toBytes(data);
|
||||
abytes(data);
|
||||
super.update(leftEncode(_8n * BigInt(data.length)));
|
||||
super.update(data);
|
||||
return this;
|
||||
};
|
||||
}
|
||||
finish() {
|
||||
if (!this.finished)
|
||||
super.update(rightEncode(this.enableXOF ? 0 : _8n * BigInt(this.outputLen))); // outputLen in bits
|
||||
super.finish();
|
||||
}
|
||||
_cloneInto(to) {
|
||||
to || (to = new TupleHash(this.blockLen, this.outputLen, this.enableXOF));
|
||||
return super._cloneInto(to);
|
||||
}
|
||||
clone() {
|
||||
return this._cloneInto();
|
||||
}
|
||||
}
|
||||
function genTuple(blockLen, outputLen, xof = false) {
|
||||
const tuple = (messages, opts) => {
|
||||
const h = tuple.create(opts);
|
||||
for (const msg of messages)
|
||||
h.update(msg);
|
||||
return h.digest();
|
||||
};
|
||||
tuple.create = (opts = {}) => new TupleHash(blockLen, chooseLen(opts, outputLen), xof, opts);
|
||||
return tuple;
|
||||
}
|
||||
/** 128-bit TupleHASH. */
|
||||
export const tuplehash128 = /* @__PURE__ */ (() => genTuple(168, 128 / 8))();
|
||||
/** 256-bit TupleHASH. */
|
||||
export const tuplehash256 = /* @__PURE__ */ (() => genTuple(136, 256 / 8))();
|
||||
/** 128-bit TupleHASH XOF. */
|
||||
export const tuplehash128xof = /* @__PURE__ */ (() => genTuple(168, 128 / 8, true))();
|
||||
/** 256-bit TupleHASH XOF. */
|
||||
export const tuplehash256xof = /* @__PURE__ */ (() => genTuple(136, 256 / 8, true))();
|
||||
export class ParallelHash extends Keccak {
|
||||
constructor(blockLen, outputLen, leafCons, enableXOF, opts = {}) {
|
||||
super(blockLen, 0x1f, outputLen, enableXOF);
|
||||
this.chunkPos = 0; // Position of current block in chunk
|
||||
this.chunksDone = 0; // How many chunks we already have
|
||||
cshakePers(this, { NISTfn: 'ParallelHash', personalization: opts.personalization });
|
||||
this.leafCons = leafCons;
|
||||
let { blockLen: B } = opts;
|
||||
B || (B = 8);
|
||||
anumber(B);
|
||||
this.chunkLen = B;
|
||||
super.update(leftEncode(B));
|
||||
// Change update after cshake processed
|
||||
this.update = (data) => {
|
||||
data = toBytes(data);
|
||||
abytes(data);
|
||||
const { chunkLen, leafCons } = this;
|
||||
for (let pos = 0, len = data.length; pos < len;) {
|
||||
if (this.chunkPos == chunkLen || !this.leafHash) {
|
||||
if (this.leafHash) {
|
||||
super.update(this.leafHash.digest());
|
||||
this.chunksDone++;
|
||||
}
|
||||
this.leafHash = leafCons();
|
||||
this.chunkPos = 0;
|
||||
}
|
||||
const take = Math.min(chunkLen - this.chunkPos, len - pos);
|
||||
this.leafHash.update(data.subarray(pos, pos + take));
|
||||
this.chunkPos += take;
|
||||
pos += take;
|
||||
}
|
||||
return this;
|
||||
};
|
||||
}
|
||||
finish() {
|
||||
if (this.finished)
|
||||
return;
|
||||
if (this.leafHash) {
|
||||
super.update(this.leafHash.digest());
|
||||
this.chunksDone++;
|
||||
}
|
||||
super.update(rightEncode(this.chunksDone));
|
||||
super.update(rightEncode(this.enableXOF ? 0 : _8n * BigInt(this.outputLen))); // outputLen in bits
|
||||
super.finish();
|
||||
}
|
||||
_cloneInto(to) {
|
||||
to || (to = new ParallelHash(this.blockLen, this.outputLen, this.leafCons, this.enableXOF));
|
||||
if (this.leafHash)
|
||||
to.leafHash = this.leafHash._cloneInto(to.leafHash);
|
||||
to.chunkPos = this.chunkPos;
|
||||
to.chunkLen = this.chunkLen;
|
||||
to.chunksDone = this.chunksDone;
|
||||
return super._cloneInto(to);
|
||||
}
|
||||
destroy() {
|
||||
super.destroy.call(this);
|
||||
if (this.leafHash)
|
||||
this.leafHash.destroy();
|
||||
}
|
||||
clone() {
|
||||
return this._cloneInto();
|
||||
}
|
||||
}
|
||||
function genPrl(blockLen, outputLen, leaf, xof = false) {
|
||||
const parallel = (message, opts) => parallel.create(opts).update(message).digest();
|
||||
parallel.create = (opts = {}) => new ParallelHash(blockLen, chooseLen(opts, outputLen), () => leaf.create({ dkLen: 2 * outputLen }), xof, opts);
|
||||
return parallel;
|
||||
}
|
||||
/** 128-bit ParallelHash. In JS, it is not parallel. */
|
||||
export const parallelhash128 = /* @__PURE__ */ (() => genPrl(168, 128 / 8, cshake128))();
|
||||
/** 256-bit ParallelHash. In JS, it is not parallel. */
|
||||
export const parallelhash256 = /* @__PURE__ */ (() => genPrl(136, 256 / 8, cshake256))();
|
||||
/** 128-bit ParallelHash XOF. In JS, it is not parallel. */
|
||||
export const parallelhash128xof = /* @__PURE__ */ (() => genPrl(168, 128 / 8, cshake128, true))();
|
||||
/** 256-bit ParallelHash. In JS, it is not parallel. */
|
||||
export const parallelhash256xof = /* @__PURE__ */ (() => genPrl(136, 256 / 8, cshake256, true))();
|
||||
const genTurboshake = (blockLen, outputLen) => createXOFer((opts = {}) => {
|
||||
const D = opts.D === undefined ? 0x1f : opts.D;
|
||||
// Section 2.1 of https://datatracker.ietf.org/doc/draft-irtf-cfrg-kangarootwelve/
|
||||
if (!Number.isSafeInteger(D) || D < 0x01 || D > 0x7f)
|
||||
throw new Error('invalid domain separation byte must be 0x01..0x7f, got: ' + D);
|
||||
return new Keccak(blockLen, D, opts.dkLen === undefined ? outputLen : opts.dkLen, true, 12);
|
||||
});
|
||||
/** TurboSHAKE 128-bit: reduced 12-round keccak. */
|
||||
export const turboshake128 = /* @__PURE__ */ genTurboshake(168, 256 / 8);
|
||||
/** TurboSHAKE 256-bit: reduced 12-round keccak. */
|
||||
export const turboshake256 = /* @__PURE__ */ genTurboshake(136, 512 / 8);
|
||||
// Kangaroo
|
||||
// Same as NIST rightEncode, but returns [0] for zero string
|
||||
function rightEncodeK12(n) {
|
||||
n = BigInt(n);
|
||||
const res = [];
|
||||
for (; n > 0; n >>= _8n)
|
||||
res.unshift(Number(n & _ffn));
|
||||
res.push(res.length);
|
||||
return Uint8Array.from(res);
|
||||
}
|
||||
const EMPTY_BUFFER = /* @__PURE__ */ Uint8Array.of();
|
||||
export class KangarooTwelve extends Keccak {
|
||||
constructor(blockLen, leafLen, outputLen, rounds, opts) {
|
||||
super(blockLen, 0x07, outputLen, true, rounds);
|
||||
this.chunkLen = 8192;
|
||||
this.chunkPos = 0; // Position of current block in chunk
|
||||
this.chunksDone = 0; // How many chunks we already have
|
||||
this.leafLen = leafLen;
|
||||
this.personalization = abytesOrZero(opts.personalization);
|
||||
}
|
||||
update(data) {
|
||||
data = toBytes(data);
|
||||
abytes(data);
|
||||
const { chunkLen, blockLen, leafLen, rounds } = this;
|
||||
for (let pos = 0, len = data.length; pos < len;) {
|
||||
if (this.chunkPos == chunkLen) {
|
||||
if (this.leafHash)
|
||||
super.update(this.leafHash.digest());
|
||||
else {
|
||||
this.suffix = 0x06; // Its safe to change suffix here since its used only in digest()
|
||||
super.update(Uint8Array.from([3, 0, 0, 0, 0, 0, 0, 0]));
|
||||
}
|
||||
this.leafHash = new Keccak(blockLen, 0x0b, leafLen, false, rounds);
|
||||
this.chunksDone++;
|
||||
this.chunkPos = 0;
|
||||
}
|
||||
const take = Math.min(chunkLen - this.chunkPos, len - pos);
|
||||
const chunk = data.subarray(pos, pos + take);
|
||||
if (this.leafHash)
|
||||
this.leafHash.update(chunk);
|
||||
else
|
||||
super.update(chunk);
|
||||
this.chunkPos += take;
|
||||
pos += take;
|
||||
}
|
||||
return this;
|
||||
}
|
||||
finish() {
|
||||
if (this.finished)
|
||||
return;
|
||||
const { personalization } = this;
|
||||
this.update(personalization).update(rightEncodeK12(personalization.length));
|
||||
// Leaf hash
|
||||
if (this.leafHash) {
|
||||
super.update(this.leafHash.digest());
|
||||
super.update(rightEncodeK12(this.chunksDone));
|
||||
super.update(Uint8Array.from([0xff, 0xff]));
|
||||
}
|
||||
super.finish.call(this);
|
||||
}
|
||||
destroy() {
|
||||
super.destroy.call(this);
|
||||
if (this.leafHash)
|
||||
this.leafHash.destroy();
|
||||
// We cannot zero personalization buffer since it is user provided and we don't want to mutate user input
|
||||
this.personalization = EMPTY_BUFFER;
|
||||
}
|
||||
_cloneInto(to) {
|
||||
const { blockLen, leafLen, leafHash, outputLen, rounds } = this;
|
||||
to || (to = new KangarooTwelve(blockLen, leafLen, outputLen, rounds, {}));
|
||||
super._cloneInto(to);
|
||||
if (leafHash)
|
||||
to.leafHash = leafHash._cloneInto(to.leafHash);
|
||||
to.personalization.set(this.personalization);
|
||||
to.leafLen = this.leafLen;
|
||||
to.chunkPos = this.chunkPos;
|
||||
to.chunksDone = this.chunksDone;
|
||||
return to;
|
||||
}
|
||||
clone() {
|
||||
return this._cloneInto();
|
||||
}
|
||||
}
|
||||
/** KangarooTwelve: reduced 12-round keccak. */
|
||||
export const k12 = /* @__PURE__ */ (() => createOptHasher((opts = {}) => new KangarooTwelve(168, 32, chooseLen(opts, 32), 12, opts)))();
|
||||
/** MarsupilamiFourteen: reduced 14-round keccak. */
|
||||
export const m14 = /* @__PURE__ */ (() => createOptHasher((opts = {}) => new KangarooTwelve(136, 64, chooseLen(opts, 64), 14, opts)))();
|
||||
/**
|
||||
* More at https://github.com/XKCP/XKCP/tree/master/lib/high/Keccak/PRG.
|
||||
*/
|
||||
export class KeccakPRG extends Keccak {
|
||||
constructor(capacity) {
|
||||
anumber(capacity);
|
||||
// Rho should be full bytes
|
||||
if (capacity < 0 || capacity > 1600 - 10 || (1600 - capacity - 2) % 8)
|
||||
throw new Error('invalid capacity');
|
||||
// blockLen = rho in bytes
|
||||
super((1600 - capacity - 2) / 8, 0, 0, true);
|
||||
this.rate = 1600 - capacity;
|
||||
this.posOut = Math.floor((this.rate + 7) / 8);
|
||||
}
|
||||
keccak() {
|
||||
// Duplex padding
|
||||
this.state[this.pos] ^= 0x01;
|
||||
this.state[this.blockLen] ^= 0x02; // Rho is full bytes
|
||||
super.keccak();
|
||||
this.pos = 0;
|
||||
this.posOut = 0;
|
||||
}
|
||||
update(data) {
|
||||
super.update(data);
|
||||
this.posOut = this.blockLen;
|
||||
return this;
|
||||
}
|
||||
feed(data) {
|
||||
return this.update(data);
|
||||
}
|
||||
finish() { }
|
||||
digestInto(_out) {
|
||||
throw new Error('digest is not allowed, use .fetch instead');
|
||||
}
|
||||
fetch(bytes) {
|
||||
return this.xof(bytes);
|
||||
}
|
||||
// Ensure irreversibility (even if state leaked previous outputs cannot be computed)
|
||||
forget() {
|
||||
if (this.rate < 1600 / 2 + 1)
|
||||
throw new Error('rate is too low to use .forget()');
|
||||
this.keccak();
|
||||
for (let i = 0; i < this.blockLen; i++)
|
||||
this.state[i] = 0;
|
||||
this.pos = this.blockLen;
|
||||
this.keccak();
|
||||
this.posOut = this.blockLen;
|
||||
}
|
||||
_cloneInto(to) {
|
||||
const { rate } = this;
|
||||
to || (to = new KeccakPRG(1600 - rate));
|
||||
super._cloneInto(to);
|
||||
to.rate = rate;
|
||||
return to;
|
||||
}
|
||||
clone() {
|
||||
return this._cloneInto();
|
||||
}
|
||||
}
|
||||
/** KeccakPRG: Pseudo-random generator based on Keccak. https://keccak.team/files/CSF-0.1.pdf */
|
||||
export const keccakprg = (capacity = 254) => new KeccakPRG(capacity);
|
||||
//# sourceMappingURL=sha3-addons.js.map
|
||||
@@ -0,0 +1,80 @@
|
||||
import { SourceMapConsumer } from 'source-map-js'
|
||||
|
||||
import { ProcessOptions } from './postcss.js'
|
||||
|
||||
declare namespace PreviousMap {
|
||||
export { PreviousMap_ as default }
|
||||
}
|
||||
|
||||
/**
|
||||
* Source map information from input CSS.
|
||||
* For example, source map after Sass compiler.
|
||||
*
|
||||
* This class will automatically find source map in input CSS or in file system
|
||||
* near input file (according `from` option).
|
||||
*
|
||||
* ```js
|
||||
* const root = parse(css, { from: 'a.sass.css' })
|
||||
* root.input.map //=> PreviousMap
|
||||
* ```
|
||||
*/
|
||||
declare class PreviousMap_ {
|
||||
/**
|
||||
* `sourceMappingURL` content.
|
||||
*/
|
||||
annotation?: string
|
||||
|
||||
/**
|
||||
* The CSS source identifier. Contains `Input#file` if the user
|
||||
* set the `from` option, or `Input#id` if they did not.
|
||||
*/
|
||||
file?: string
|
||||
|
||||
/**
|
||||
* Was source map inlined by data-uri to input CSS.
|
||||
*/
|
||||
inline: boolean
|
||||
|
||||
/**
|
||||
* Path to source map file.
|
||||
*/
|
||||
mapFile?: string
|
||||
|
||||
/**
|
||||
* The directory with source map file, if source map is in separated file.
|
||||
*/
|
||||
root?: string
|
||||
|
||||
/**
|
||||
* Source map file content.
|
||||
*/
|
||||
text?: string
|
||||
|
||||
/**
|
||||
* @param css Input CSS source.
|
||||
* @param opts Process options.
|
||||
*/
|
||||
constructor(css: string, opts?: ProcessOptions)
|
||||
|
||||
/**
|
||||
* Create a instance of `SourceMapGenerator` class
|
||||
* from the `source-map` library to work with source map information.
|
||||
*
|
||||
* It is lazy method, so it will create object only on first call
|
||||
* and then it will use cache.
|
||||
*
|
||||
* @return Object with source map information.
|
||||
*/
|
||||
consumer(): SourceMapConsumer
|
||||
|
||||
/**
|
||||
* Does source map contains `sourcesContent` with input source text.
|
||||
*
|
||||
* @return Is `sourcesContent` present.
|
||||
*/
|
||||
withContent(): boolean
|
||||
}
|
||||
|
||||
declare class PreviousMap extends PreviousMap_ {}
|
||||
|
||||
export = PreviousMap
|
||||
@@ -0,0 +1,30 @@
|
||||
{{# def.definitions }}
|
||||
{{# def.errors }}
|
||||
{{# def.setupKeyword }}
|
||||
{{# def.$data }}
|
||||
|
||||
{{
|
||||
var $i = 'i' + $lvl
|
||||
, $vSchema = 'schema' + $lvl;
|
||||
}}
|
||||
|
||||
{{? !$isData }}
|
||||
var {{=$vSchema}} = validate.schema{{=$schemaPath}};
|
||||
{{?}}
|
||||
var {{=$valid}};
|
||||
|
||||
{{?$isData}}{{# def.check$dataIsArray }}{{?}}
|
||||
|
||||
{{=$valid}} = false;
|
||||
|
||||
for (var {{=$i}}=0; {{=$i}}<{{=$vSchema}}.length; {{=$i}}++)
|
||||
if (equal({{=$data}}, {{=$vSchema}}[{{=$i}}])) {
|
||||
{{=$valid}} = true;
|
||||
break;
|
||||
}
|
||||
|
||||
{{? $isData }} } {{?}}
|
||||
|
||||
{{# def.checkError:'enum' }}
|
||||
|
||||
{{? $breakOnError }} else { {{?}}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,102 @@
|
||||
/**
|
||||
* hash-to-curve from RFC 9380.
|
||||
* Hashes arbitrary-length byte strings to a list of one or more elements of a finite field F.
|
||||
* https://www.rfc-editor.org/rfc/rfc9380
|
||||
* @module
|
||||
*/
|
||||
/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
|
||||
import type { CHash } from '../utils.ts';
|
||||
import type { AffinePoint, Group, GroupConstructor } from './curve.ts';
|
||||
import { type IField } from './modular.ts';
|
||||
export type UnicodeOrBytes = string | Uint8Array;
|
||||
/**
|
||||
* * `DST` is a domain separation tag, defined in section 2.2.5
|
||||
* * `p` characteristic of F, where F is a finite field of characteristic p and order q = p^m
|
||||
* * `m` is extension degree (1 for prime fields)
|
||||
* * `k` is the target security target in bits (e.g. 128), from section 5.1
|
||||
* * `expand` is `xmd` (SHA2, SHA3, BLAKE) or `xof` (SHAKE, BLAKE-XOF)
|
||||
* * `hash` conforming to `utils.CHash` interface, with `outputLen` / `blockLen` props
|
||||
*/
|
||||
export type H2COpts = {
|
||||
DST: UnicodeOrBytes;
|
||||
expand: 'xmd' | 'xof';
|
||||
hash: CHash;
|
||||
p: bigint;
|
||||
m: number;
|
||||
k: number;
|
||||
};
|
||||
export type H2CHashOpts = {
|
||||
expand: 'xmd' | 'xof';
|
||||
hash: CHash;
|
||||
};
|
||||
export type Opts = H2COpts;
|
||||
/**
|
||||
* Produces a uniformly random byte string using a cryptographic hash function H that outputs b bits.
|
||||
* [RFC 9380 5.3.1](https://www.rfc-editor.org/rfc/rfc9380#section-5.3.1).
|
||||
*/
|
||||
export declare function expand_message_xmd(msg: Uint8Array, DST: UnicodeOrBytes, lenInBytes: number, H: CHash): Uint8Array;
|
||||
/**
|
||||
* Produces a uniformly random byte string using an extendable-output function (XOF) H.
|
||||
* 1. The collision resistance of H MUST be at least k bits.
|
||||
* 2. H MUST be an XOF that has been proved indifferentiable from
|
||||
* a random oracle under a reasonable cryptographic assumption.
|
||||
* [RFC 9380 5.3.2](https://www.rfc-editor.org/rfc/rfc9380#section-5.3.2).
|
||||
*/
|
||||
export declare function expand_message_xof(msg: Uint8Array, DST: UnicodeOrBytes, lenInBytes: number, k: number, H: CHash): Uint8Array;
|
||||
/**
|
||||
* Hashes arbitrary-length byte strings to a list of one or more elements of a finite field F.
|
||||
* [RFC 9380 5.2](https://www.rfc-editor.org/rfc/rfc9380#section-5.2).
|
||||
* @param msg a byte string containing the message to hash
|
||||
* @param count the number of elements of F to output
|
||||
* @param options `{DST: string, p: bigint, m: number, k: number, expand: 'xmd' | 'xof', hash: H}`, see above
|
||||
* @returns [u_0, ..., u_(count - 1)], a list of field elements.
|
||||
*/
|
||||
export declare function hash_to_field(msg: Uint8Array, count: number, options: H2COpts): bigint[][];
|
||||
export type XY<T> = (x: T, y: T) => {
|
||||
x: T;
|
||||
y: T;
|
||||
};
|
||||
export type XYRatio<T> = [T[], T[], T[], T[]];
|
||||
export declare function isogenyMap<T, F extends IField<T>>(field: F, map: XYRatio<T>): XY<T>;
|
||||
/** Point interface, which curves must implement to work correctly with the module. */
|
||||
export interface H2CPoint<T> extends Group<H2CPoint<T>> {
|
||||
add(rhs: H2CPoint<T>): H2CPoint<T>;
|
||||
toAffine(iz?: bigint): AffinePoint<T>;
|
||||
clearCofactor(): H2CPoint<T>;
|
||||
assertValidity(): void;
|
||||
}
|
||||
export interface H2CPointConstructor<T> extends GroupConstructor<H2CPoint<T>> {
|
||||
fromAffine(ap: AffinePoint<T>): H2CPoint<T>;
|
||||
}
|
||||
export type MapToCurve<T> = (scalar: bigint[]) => AffinePoint<T>;
|
||||
export type htfBasicOpts = {
|
||||
DST: UnicodeOrBytes;
|
||||
};
|
||||
export type H2CMethod<T> = (msg: Uint8Array, options?: htfBasicOpts) => H2CPoint<T>;
|
||||
export type HTFMethod<T> = H2CMethod<T>;
|
||||
export type MapMethod<T> = (scalars: bigint[]) => H2CPoint<T>;
|
||||
export type H2CHasherBase<T> = {
|
||||
hashToCurve: H2CMethod<T>;
|
||||
hashToScalar: (msg: Uint8Array, options: htfBasicOpts) => bigint;
|
||||
};
|
||||
/**
|
||||
* RFC 9380 methods, with cofactor clearing. See https://www.rfc-editor.org/rfc/rfc9380#section-3.
|
||||
*
|
||||
* * hashToCurve: `map(hash(input))`, encodes RANDOM bytes to curve (WITH hashing)
|
||||
* * encodeToCurve: `map(hash(input))`, encodes NON-UNIFORM bytes to curve (WITH hashing)
|
||||
* * mapToCurve: `map(scalars)`, encodes NON-UNIFORM scalars to curve (NO hashing)
|
||||
*/
|
||||
export type H2CHasher<T> = H2CHasherBase<T> & {
|
||||
encodeToCurve: H2CMethod<T>;
|
||||
mapToCurve: MapMethod<T>;
|
||||
defaults: H2COpts & {
|
||||
encodeDST?: UnicodeOrBytes;
|
||||
};
|
||||
};
|
||||
export type Hasher<T> = H2CHasher<T>;
|
||||
export declare const _DST_scalar: Uint8Array;
|
||||
/** Creates hash-to-curve methods from EC Point and mapToCurve function. See {@link H2CHasher}. */
|
||||
export declare function createHasher<T>(Point: H2CPointConstructor<T>, mapToCurve: MapToCurve<T>, defaults: H2COpts & {
|
||||
encodeDST?: UnicodeOrBytes;
|
||||
}): H2CHasher<T>;
|
||||
//# sourceMappingURL=hash-to-curve.d.ts.map
|
||||
@@ -0,0 +1,132 @@
|
||||
/* -*- Mode: js; js-indent-level: 2; -*- */
|
||||
/*
|
||||
* Copyright 2011 Mozilla Foundation and contributors
|
||||
* Licensed under the New BSD license. See LICENSE or:
|
||||
* http://opensource.org/licenses/BSD-3-Clause
|
||||
*/
|
||||
|
||||
// It turns out that some (most?) JavaScript engines don't self-host
|
||||
// `Array.prototype.sort`. This makes sense because C++ will likely remain
|
||||
// faster than JS when doing raw CPU-intensive sorting. However, when using a
|
||||
// custom comparator function, calling back and forth between the VM's C++ and
|
||||
// JIT'd JS is rather slow *and* loses JIT type information, resulting in
|
||||
// worse generated code for the comparator function than would be optimal. In
|
||||
// fact, when sorting with a comparator, these costs outweigh the benefits of
|
||||
// sorting in C++. By using our own JS-implemented Quick Sort (below), we get
|
||||
// a ~3500ms mean speed-up in `bench/bench.html`.
|
||||
|
||||
function SortTemplate(comparator) {
|
||||
|
||||
/**
|
||||
* Swap the elements indexed by `x` and `y` in the array `ary`.
|
||||
*
|
||||
* @param {Array} ary
|
||||
* The array.
|
||||
* @param {Number} x
|
||||
* The index of the first item.
|
||||
* @param {Number} y
|
||||
* The index of the second item.
|
||||
*/
|
||||
function swap(ary, x, y) {
|
||||
var temp = ary[x];
|
||||
ary[x] = ary[y];
|
||||
ary[y] = temp;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a random integer within the range `low .. high` inclusive.
|
||||
*
|
||||
* @param {Number} low
|
||||
* The lower bound on the range.
|
||||
* @param {Number} high
|
||||
* The upper bound on the range.
|
||||
*/
|
||||
function randomIntInRange(low, high) {
|
||||
return Math.round(low + (Math.random() * (high - low)));
|
||||
}
|
||||
|
||||
/**
|
||||
* The Quick Sort algorithm.
|
||||
*
|
||||
* @param {Array} ary
|
||||
* An array to sort.
|
||||
* @param {function} comparator
|
||||
* Function to use to compare two items.
|
||||
* @param {Number} p
|
||||
* Start index of the array
|
||||
* @param {Number} r
|
||||
* End index of the array
|
||||
*/
|
||||
function doQuickSort(ary, comparator, p, r) {
|
||||
// If our lower bound is less than our upper bound, we (1) partition the
|
||||
// array into two pieces and (2) recurse on each half. If it is not, this is
|
||||
// the empty array and our base case.
|
||||
|
||||
if (p < r) {
|
||||
// (1) Partitioning.
|
||||
//
|
||||
// The partitioning chooses a pivot between `p` and `r` and moves all
|
||||
// elements that are less than or equal to the pivot to the before it, and
|
||||
// all the elements that are greater than it after it. The effect is that
|
||||
// once partition is done, the pivot is in the exact place it will be when
|
||||
// the array is put in sorted order, and it will not need to be moved
|
||||
// again. This runs in O(n) time.
|
||||
|
||||
// Always choose a random pivot so that an input array which is reverse
|
||||
// sorted does not cause O(n^2) running time.
|
||||
var pivotIndex = randomIntInRange(p, r);
|
||||
var i = p - 1;
|
||||
|
||||
swap(ary, pivotIndex, r);
|
||||
var pivot = ary[r];
|
||||
|
||||
// Immediately after `j` is incremented in this loop, the following hold
|
||||
// true:
|
||||
//
|
||||
// * Every element in `ary[p .. i]` is less than or equal to the pivot.
|
||||
//
|
||||
// * Every element in `ary[i+1 .. j-1]` is greater than the pivot.
|
||||
for (var j = p; j < r; j++) {
|
||||
if (comparator(ary[j], pivot, false) <= 0) {
|
||||
i += 1;
|
||||
swap(ary, i, j);
|
||||
}
|
||||
}
|
||||
|
||||
swap(ary, i + 1, j);
|
||||
var q = i + 1;
|
||||
|
||||
// (2) Recurse on each half.
|
||||
|
||||
doQuickSort(ary, comparator, p, q - 1);
|
||||
doQuickSort(ary, comparator, q + 1, r);
|
||||
}
|
||||
}
|
||||
|
||||
return doQuickSort;
|
||||
}
|
||||
|
||||
function cloneSort(comparator) {
|
||||
let template = SortTemplate.toString();
|
||||
let templateFn = new Function(`return ${template}`)();
|
||||
return templateFn(comparator);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sort the given array in-place with the given comparator function.
|
||||
*
|
||||
* @param {Array} ary
|
||||
* An array to sort.
|
||||
* @param {function} comparator
|
||||
* Function to use to compare two items.
|
||||
*/
|
||||
|
||||
let sortCache = new WeakMap();
|
||||
exports.quickSort = function (ary, comparator, start = 0) {
|
||||
let doQuickSort = sortCache.get(comparator);
|
||||
if (doQuickSort === void 0) {
|
||||
doQuickSort = cloneSort(comparator);
|
||||
sortCache.set(comparator, doQuickSort);
|
||||
}
|
||||
doQuickSort(ary, comparator, start, ary.length - 1);
|
||||
};
|
||||
@@ -0,0 +1,42 @@
|
||||
/*! *****************************************************************************
|
||||
Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
|
||||
this file except in compliance with the License. You may obtain a copy of the
|
||||
License at http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
|
||||
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
|
||||
MERCHANTABLITY OR NON-INFRINGEMENT.
|
||||
|
||||
See the Apache Version 2.0 License for specific language governing permissions
|
||||
and limitations under the License.
|
||||
***************************************************************************** */
|
||||
|
||||
|
||||
/// <reference no-default-lib="true"/>
|
||||
|
||||
/// <reference lib="es2020.intl" />
|
||||
|
||||
interface Date {
|
||||
/**
|
||||
* Converts a date and time to a string by using the current or specified locale.
|
||||
* @param locales A locale string, array of locale strings, Intl.Locale object, or array of Intl.Locale objects that contain one or more language or locale tags. If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used.
|
||||
* @param options An object that contains one or more properties that specify comparison options.
|
||||
*/
|
||||
toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
|
||||
|
||||
/**
|
||||
* Converts a date to a string by using the current or specified locale.
|
||||
* @param locales A locale string, array of locale strings, Intl.Locale object, or array of Intl.Locale objects that contain one or more language or locale tags. If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used.
|
||||
* @param options An object that contains one or more properties that specify comparison options.
|
||||
*/
|
||||
toLocaleDateString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
|
||||
|
||||
/**
|
||||
* Converts a time to a string by using the current or specified locale.
|
||||
* @param locales A locale string, array of locale strings, Intl.Locale object, or array of Intl.Locale objects that contain one or more language or locale tags. If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used.
|
||||
* @param options An object that contains one or more properties that specify comparison options.
|
||||
*/
|
||||
toLocaleTimeString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
|
||||
}
|
||||
Reference in New Issue
Block a user