WIP: bootstrap and partial real Solana watcher implementation
This commit is contained in:
@@ -0,0 +1,345 @@
|
||||
import { StringReader, StringWriter } from './strings';
|
||||
import { comma, decodeInteger, encodeInteger, hasMoreVlq, semicolon } from './vlq';
|
||||
|
||||
const EMPTY: any[] = [];
|
||||
|
||||
type Line = number;
|
||||
type Column = number;
|
||||
type Kind = number;
|
||||
type Name = number;
|
||||
type Var = number;
|
||||
type SourcesIndex = number;
|
||||
type ScopesIndex = number;
|
||||
|
||||
type Mix<A, B, O> = (A & O) | (B & O);
|
||||
|
||||
export type OriginalScope = Mix<
|
||||
[Line, Column, Line, Column, Kind],
|
||||
[Line, Column, Line, Column, Kind, Name],
|
||||
{ vars: Var[] }
|
||||
>;
|
||||
|
||||
export type GeneratedRange = Mix<
|
||||
[Line, Column, Line, Column],
|
||||
[Line, Column, Line, Column, SourcesIndex, ScopesIndex],
|
||||
{
|
||||
callsite: CallSite | null;
|
||||
bindings: Binding[];
|
||||
isScope: boolean;
|
||||
}
|
||||
>;
|
||||
export type CallSite = [SourcesIndex, Line, Column];
|
||||
type Binding = BindingExpressionRange[];
|
||||
export type BindingExpressionRange = [Name] | [Name, Line, Column];
|
||||
|
||||
export function decodeOriginalScopes(input: string): OriginalScope[] {
|
||||
const { length } = input;
|
||||
const reader = new StringReader(input);
|
||||
const scopes: OriginalScope[] = [];
|
||||
const stack: OriginalScope[] = [];
|
||||
let line = 0;
|
||||
|
||||
for (; reader.pos < length; reader.pos++) {
|
||||
line = decodeInteger(reader, line);
|
||||
const column = decodeInteger(reader, 0);
|
||||
|
||||
if (!hasMoreVlq(reader, length)) {
|
||||
const last = stack.pop()!;
|
||||
last[2] = line;
|
||||
last[3] = column;
|
||||
continue;
|
||||
}
|
||||
|
||||
const kind = decodeInteger(reader, 0);
|
||||
const fields = decodeInteger(reader, 0);
|
||||
const hasName = fields & 0b0001;
|
||||
|
||||
const scope: OriginalScope = (
|
||||
hasName ? [line, column, 0, 0, kind, decodeInteger(reader, 0)] : [line, column, 0, 0, kind]
|
||||
) as OriginalScope;
|
||||
|
||||
let vars: Var[] = EMPTY;
|
||||
if (hasMoreVlq(reader, length)) {
|
||||
vars = [];
|
||||
do {
|
||||
const varsIndex = decodeInteger(reader, 0);
|
||||
vars.push(varsIndex);
|
||||
} while (hasMoreVlq(reader, length));
|
||||
}
|
||||
scope.vars = vars;
|
||||
|
||||
scopes.push(scope);
|
||||
stack.push(scope);
|
||||
}
|
||||
|
||||
return scopes;
|
||||
}
|
||||
|
||||
export function encodeOriginalScopes(scopes: OriginalScope[]): string {
|
||||
const writer = new StringWriter();
|
||||
|
||||
for (let i = 0; i < scopes.length; ) {
|
||||
i = _encodeOriginalScopes(scopes, i, writer, [0]);
|
||||
}
|
||||
|
||||
return writer.flush();
|
||||
}
|
||||
|
||||
function _encodeOriginalScopes(
|
||||
scopes: OriginalScope[],
|
||||
index: number,
|
||||
writer: StringWriter,
|
||||
state: [
|
||||
number, // GenColumn
|
||||
],
|
||||
): number {
|
||||
const scope = scopes[index];
|
||||
const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, 4: kind, vars } = scope;
|
||||
|
||||
if (index > 0) writer.write(comma);
|
||||
|
||||
state[0] = encodeInteger(writer, startLine, state[0]);
|
||||
encodeInteger(writer, startColumn, 0);
|
||||
encodeInteger(writer, kind, 0);
|
||||
|
||||
const fields = scope.length === 6 ? 0b0001 : 0;
|
||||
encodeInteger(writer, fields, 0);
|
||||
if (scope.length === 6) encodeInteger(writer, scope[5], 0);
|
||||
|
||||
for (const v of vars) {
|
||||
encodeInteger(writer, v, 0);
|
||||
}
|
||||
|
||||
for (index++; index < scopes.length; ) {
|
||||
const next = scopes[index];
|
||||
const { 0: l, 1: c } = next;
|
||||
if (l > endLine || (l === endLine && c >= endColumn)) {
|
||||
break;
|
||||
}
|
||||
index = _encodeOriginalScopes(scopes, index, writer, state);
|
||||
}
|
||||
|
||||
writer.write(comma);
|
||||
state[0] = encodeInteger(writer, endLine, state[0]);
|
||||
encodeInteger(writer, endColumn, 0);
|
||||
|
||||
return index;
|
||||
}
|
||||
|
||||
export function decodeGeneratedRanges(input: string): GeneratedRange[] {
|
||||
const { length } = input;
|
||||
const reader = new StringReader(input);
|
||||
const ranges: GeneratedRange[] = [];
|
||||
const stack: GeneratedRange[] = [];
|
||||
|
||||
let genLine = 0;
|
||||
let definitionSourcesIndex = 0;
|
||||
let definitionScopeIndex = 0;
|
||||
let callsiteSourcesIndex = 0;
|
||||
let callsiteLine = 0;
|
||||
let callsiteColumn = 0;
|
||||
let bindingLine = 0;
|
||||
let bindingColumn = 0;
|
||||
|
||||
do {
|
||||
const semi = reader.indexOf(';');
|
||||
let genColumn = 0;
|
||||
|
||||
for (; reader.pos < semi; reader.pos++) {
|
||||
genColumn = decodeInteger(reader, genColumn);
|
||||
|
||||
if (!hasMoreVlq(reader, semi)) {
|
||||
const last = stack.pop()!;
|
||||
last[2] = genLine;
|
||||
last[3] = genColumn;
|
||||
continue;
|
||||
}
|
||||
|
||||
const fields = decodeInteger(reader, 0);
|
||||
const hasDefinition = fields & 0b0001;
|
||||
const hasCallsite = fields & 0b0010;
|
||||
const hasScope = fields & 0b0100;
|
||||
|
||||
let callsite: CallSite | null = null;
|
||||
let bindings: Binding[] = EMPTY;
|
||||
let range: GeneratedRange;
|
||||
if (hasDefinition) {
|
||||
const defSourcesIndex = decodeInteger(reader, definitionSourcesIndex);
|
||||
definitionScopeIndex = decodeInteger(
|
||||
reader,
|
||||
definitionSourcesIndex === defSourcesIndex ? definitionScopeIndex : 0,
|
||||
);
|
||||
|
||||
definitionSourcesIndex = defSourcesIndex;
|
||||
range = [genLine, genColumn, 0, 0, defSourcesIndex, definitionScopeIndex] as GeneratedRange;
|
||||
} else {
|
||||
range = [genLine, genColumn, 0, 0] as GeneratedRange;
|
||||
}
|
||||
|
||||
range.isScope = !!hasScope;
|
||||
|
||||
if (hasCallsite) {
|
||||
const prevCsi = callsiteSourcesIndex;
|
||||
const prevLine = callsiteLine;
|
||||
callsiteSourcesIndex = decodeInteger(reader, callsiteSourcesIndex);
|
||||
const sameSource = prevCsi === callsiteSourcesIndex;
|
||||
callsiteLine = decodeInteger(reader, sameSource ? callsiteLine : 0);
|
||||
callsiteColumn = decodeInteger(
|
||||
reader,
|
||||
sameSource && prevLine === callsiteLine ? callsiteColumn : 0,
|
||||
);
|
||||
|
||||
callsite = [callsiteSourcesIndex, callsiteLine, callsiteColumn];
|
||||
}
|
||||
range.callsite = callsite;
|
||||
|
||||
if (hasMoreVlq(reader, semi)) {
|
||||
bindings = [];
|
||||
do {
|
||||
bindingLine = genLine;
|
||||
bindingColumn = genColumn;
|
||||
const expressionsCount = decodeInteger(reader, 0);
|
||||
let expressionRanges: BindingExpressionRange[];
|
||||
if (expressionsCount < -1) {
|
||||
expressionRanges = [[decodeInteger(reader, 0)]];
|
||||
for (let i = -1; i > expressionsCount; i--) {
|
||||
const prevBl = bindingLine;
|
||||
bindingLine = decodeInteger(reader, bindingLine);
|
||||
bindingColumn = decodeInteger(reader, bindingLine === prevBl ? bindingColumn : 0);
|
||||
const expression = decodeInteger(reader, 0);
|
||||
expressionRanges.push([expression, bindingLine, bindingColumn]);
|
||||
}
|
||||
} else {
|
||||
expressionRanges = [[expressionsCount]];
|
||||
}
|
||||
bindings.push(expressionRanges);
|
||||
} while (hasMoreVlq(reader, semi));
|
||||
}
|
||||
range.bindings = bindings;
|
||||
|
||||
ranges.push(range);
|
||||
stack.push(range);
|
||||
}
|
||||
|
||||
genLine++;
|
||||
reader.pos = semi + 1;
|
||||
} while (reader.pos < length);
|
||||
|
||||
return ranges;
|
||||
}
|
||||
|
||||
export function encodeGeneratedRanges(ranges: GeneratedRange[]): string {
|
||||
if (ranges.length === 0) return '';
|
||||
|
||||
const writer = new StringWriter();
|
||||
|
||||
for (let i = 0; i < ranges.length; ) {
|
||||
i = _encodeGeneratedRanges(ranges, i, writer, [0, 0, 0, 0, 0, 0, 0]);
|
||||
}
|
||||
|
||||
return writer.flush();
|
||||
}
|
||||
|
||||
function _encodeGeneratedRanges(
|
||||
ranges: GeneratedRange[],
|
||||
index: number,
|
||||
writer: StringWriter,
|
||||
state: [
|
||||
number, // GenLine
|
||||
number, // GenColumn
|
||||
number, // DefSourcesIndex
|
||||
number, // DefScopesIndex
|
||||
number, // CallSourcesIndex
|
||||
number, // CallLine
|
||||
number, // CallColumn
|
||||
],
|
||||
): number {
|
||||
const range = ranges[index];
|
||||
const {
|
||||
0: startLine,
|
||||
1: startColumn,
|
||||
2: endLine,
|
||||
3: endColumn,
|
||||
isScope,
|
||||
callsite,
|
||||
bindings,
|
||||
} = range;
|
||||
|
||||
if (state[0] < startLine) {
|
||||
catchupLine(writer, state[0], startLine);
|
||||
state[0] = startLine;
|
||||
state[1] = 0;
|
||||
} else if (index > 0) {
|
||||
writer.write(comma);
|
||||
}
|
||||
|
||||
state[1] = encodeInteger(writer, range[1], state[1]);
|
||||
|
||||
const fields =
|
||||
(range.length === 6 ? 0b0001 : 0) | (callsite ? 0b0010 : 0) | (isScope ? 0b0100 : 0);
|
||||
encodeInteger(writer, fields, 0);
|
||||
|
||||
if (range.length === 6) {
|
||||
const { 4: sourcesIndex, 5: scopesIndex } = range;
|
||||
if (sourcesIndex !== state[2]) {
|
||||
state[3] = 0;
|
||||
}
|
||||
state[2] = encodeInteger(writer, sourcesIndex, state[2]);
|
||||
state[3] = encodeInteger(writer, scopesIndex, state[3]);
|
||||
}
|
||||
|
||||
if (callsite) {
|
||||
const { 0: sourcesIndex, 1: callLine, 2: callColumn } = range.callsite!;
|
||||
if (sourcesIndex !== state[4]) {
|
||||
state[5] = 0;
|
||||
state[6] = 0;
|
||||
} else if (callLine !== state[5]) {
|
||||
state[6] = 0;
|
||||
}
|
||||
state[4] = encodeInteger(writer, sourcesIndex, state[4]);
|
||||
state[5] = encodeInteger(writer, callLine, state[5]);
|
||||
state[6] = encodeInteger(writer, callColumn, state[6]);
|
||||
}
|
||||
|
||||
if (bindings) {
|
||||
for (const binding of bindings) {
|
||||
if (binding.length > 1) encodeInteger(writer, -binding.length, 0);
|
||||
const expression = binding[0][0];
|
||||
encodeInteger(writer, expression, 0);
|
||||
let bindingStartLine = startLine;
|
||||
let bindingStartColumn = startColumn;
|
||||
for (let i = 1; i < binding.length; i++) {
|
||||
const expRange = binding[i];
|
||||
bindingStartLine = encodeInteger(writer, expRange[1]!, bindingStartLine);
|
||||
bindingStartColumn = encodeInteger(writer, expRange[2]!, bindingStartColumn);
|
||||
encodeInteger(writer, expRange[0]!, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (index++; index < ranges.length; ) {
|
||||
const next = ranges[index];
|
||||
const { 0: l, 1: c } = next;
|
||||
if (l > endLine || (l === endLine && c >= endColumn)) {
|
||||
break;
|
||||
}
|
||||
index = _encodeGeneratedRanges(ranges, index, writer, state);
|
||||
}
|
||||
|
||||
if (state[0] < endLine) {
|
||||
catchupLine(writer, state[0], endLine);
|
||||
state[0] = endLine;
|
||||
state[1] = 0;
|
||||
} else {
|
||||
writer.write(comma);
|
||||
}
|
||||
state[1] = encodeInteger(writer, endColumn, state[1]);
|
||||
|
||||
return index;
|
||||
}
|
||||
|
||||
function catchupLine(writer: StringWriter, lastLine: number, line: number) {
|
||||
do {
|
||||
writer.write(semicolon);
|
||||
} while (++lastLine < line);
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
import { expect, expectTypeOf, test } from "vitest";
|
||||
import * as z from "zod/v4";
|
||||
|
||||
function nest<TData extends z.ZodType>(schema: TData) {
|
||||
return z.object({
|
||||
nested: schema,
|
||||
});
|
||||
}
|
||||
|
||||
test("generics", () => {
|
||||
const a = nest(z.object({ a: z.string() }));
|
||||
type a = z.infer<typeof a>;
|
||||
expectTypeOf<a>().toEqualTypeOf<{ nested: { a: string } }>();
|
||||
|
||||
const b = nest(z.object({ a: z.string().optional() }));
|
||||
type b = z.infer<typeof b>;
|
||||
expectTypeOf<b>().toEqualTypeOf<{ nested: { a?: string | undefined } }>();
|
||||
});
|
||||
|
||||
test("generics with optional", () => {
|
||||
async function stripOuter<TData extends z.ZodType>(schema: TData, data: unknown) {
|
||||
return z
|
||||
.object({
|
||||
nested: schema.optional(),
|
||||
})
|
||||
.transform((data) => {
|
||||
return data.nested;
|
||||
})
|
||||
.parse({ nested: data });
|
||||
}
|
||||
|
||||
const result = stripOuter(z.object({ a: z.string() }), { a: "asdf" });
|
||||
expectTypeOf<typeof result>().toEqualTypeOf<Promise<{ a: string } | undefined>>();
|
||||
});
|
||||
|
||||
// test("assignability", () => {
|
||||
// const createSchemaAndParse = <K extends string, VS extends z.ZodString>(key: K, valueSchema: VS, data: unknown) => {
|
||||
// const schema = z.object({
|
||||
// [key]: valueSchema,
|
||||
// });
|
||||
// // return { [key]: valueSchema };
|
||||
// const parsed = schema.parse(data);
|
||||
// return parsed;
|
||||
// // const inferred: z.infer<z.ZodObject<{ [k in K]: VS }>> = parsed;
|
||||
// // return inferred;
|
||||
// };
|
||||
// const parsed = createSchemaAndParse("foo", z.string(), { foo: "" });
|
||||
// expectTypeOf<typeof parsed>().toEqualTypeOf<{ foo: string }>();
|
||||
// });
|
||||
|
||||
test("nested no undefined", () => {
|
||||
const inner = z.string().or(z.array(z.string()));
|
||||
const outer = z.object({ inner });
|
||||
type outerSchema = z.infer<typeof outer>;
|
||||
expectTypeOf<outerSchema>().toEqualTypeOf<{ inner: string | string[] }>();
|
||||
|
||||
expect(outer.safeParse({ inner: undefined }).success).toEqual(false);
|
||||
});
|
||||
|
||||
test("generic on output type", () => {
|
||||
const createV4Schema = <Output>(opts: {
|
||||
schema: z.ZodType<Output>;
|
||||
}) => {
|
||||
return opts.schema;
|
||||
};
|
||||
|
||||
createV4Schema({
|
||||
schema: z.object({
|
||||
name: z.string(),
|
||||
}),
|
||||
})?._zod?.output?.name;
|
||||
});
|
||||
@@ -0,0 +1,33 @@
|
||||
/**
|
||||
* Generate URL-friendly unique ID. This method uses the non-secure
|
||||
* predictable random generator with bigger collision probability.
|
||||
*
|
||||
* ```js
|
||||
* import { nanoid } from 'nanoid/non-secure'
|
||||
* model.id = nanoid() //=> "Uakgb_J5m9g-0JDMbcJqL"
|
||||
* ```
|
||||
*
|
||||
* @param size Size of the ID. The default size is 21.
|
||||
* @returns A random string.
|
||||
*/
|
||||
export function nanoid(size?: number): string
|
||||
|
||||
/**
|
||||
* Generate a unique ID based on a custom alphabet.
|
||||
* This method uses the non-secure predictable random generator
|
||||
* with bigger collision probability.
|
||||
*
|
||||
* @param alphabet Alphabet used to generate the ID.
|
||||
* @param defaultSize Size of the ID. The default size is 21.
|
||||
* @returns A random string generator.
|
||||
*
|
||||
* ```js
|
||||
* import { customAlphabet } from 'nanoid/non-secure'
|
||||
* const nanoid = customAlphabet('0123456789абвгдеё', 5)
|
||||
* model.id = //=> "8ё56а"
|
||||
* ```
|
||||
*/
|
||||
export function customAlphabet(
|
||||
alphabet: string,
|
||||
defaultSize?: number
|
||||
): (size?: number) => string
|
||||
@@ -0,0 +1,8 @@
|
||||
"use strict";
|
||||
|
||||
function _class_check_private_static_field_descriptor(descriptor, action) {
|
||||
if (descriptor === undefined) {
|
||||
throw new TypeError("attempted to " + action + " private static field before its declaration");
|
||||
}
|
||||
}
|
||||
exports._ = _class_check_private_static_field_descriptor;
|
||||
@@ -0,0 +1,87 @@
|
||||
/**
|
||||
* @fileoverview Rule to flag when return statement contains assignment
|
||||
* @author Ilya Volodin
|
||||
*/
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Requirements
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const astUtils = require("./utils/ast-utils");
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const SENTINEL_TYPE =
|
||||
/^(?:[a-zA-Z]+?Statement|ArrowFunctionExpression|FunctionExpression|ClassExpression)$/u;
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../types').Rule.RuleModule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "suggestion",
|
||||
|
||||
defaultOptions: ["except-parens"],
|
||||
|
||||
docs: {
|
||||
description: "Disallow assignment operators in `return` statements",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/no-return-assign",
|
||||
},
|
||||
|
||||
schema: [
|
||||
{
|
||||
enum: ["except-parens", "always"],
|
||||
},
|
||||
],
|
||||
|
||||
messages: {
|
||||
returnAssignment: "Return statement should not contain assignment.",
|
||||
arrowAssignment: "Arrow function should not return assignment.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const always = context.options[0] !== "except-parens";
|
||||
const sourceCode = context.sourceCode;
|
||||
|
||||
return {
|
||||
AssignmentExpression(node) {
|
||||
if (!always && astUtils.isParenthesised(sourceCode, node)) {
|
||||
return;
|
||||
}
|
||||
|
||||
let currentChild = node;
|
||||
let parent = currentChild.parent;
|
||||
|
||||
// Find ReturnStatement or ArrowFunctionExpression in ancestors.
|
||||
while (parent && !SENTINEL_TYPE.test(parent.type)) {
|
||||
currentChild = parent;
|
||||
parent = parent.parent;
|
||||
}
|
||||
|
||||
// Reports.
|
||||
if (parent && parent.type === "ReturnStatement") {
|
||||
context.report({
|
||||
node: parent,
|
||||
messageId: "returnAssignment",
|
||||
});
|
||||
} else if (
|
||||
parent &&
|
||||
parent.type === "ArrowFunctionExpression" &&
|
||||
parent.body === currentChild
|
||||
) {
|
||||
context.report({
|
||||
node: parent,
|
||||
messageId: "arrowAssignment",
|
||||
});
|
||||
}
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,28 @@
|
||||
/*! *****************************************************************************
|
||||
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.
|
||||
***************************************************************************** */
|
||||
|
||||
|
||||
/**
|
||||
* Represents the completion of an asynchronous operation
|
||||
*/
|
||||
interface Promise<T> {
|
||||
/**
|
||||
* Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
|
||||
* resolved value cannot be modified from the callback.
|
||||
* @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
|
||||
* @returns A Promise for the completion of the callback.
|
||||
*/
|
||||
finally(onfinally?: (() => void) | undefined | null): Promise<T>;
|
||||
}
|
||||
@@ -0,0 +1,326 @@
|
||||
import { expect, expectTypeOf, test } from "vitest";
|
||||
import { z } from "zod/v4";
|
||||
|
||||
test("basic catch", () => {
|
||||
expect(z.string().catch("default").parse(undefined)).toBe("default");
|
||||
});
|
||||
|
||||
test("catch fn does not run when parsing succeeds", () => {
|
||||
let isCalled = false;
|
||||
const cb = () => {
|
||||
isCalled = true;
|
||||
return "asdf";
|
||||
};
|
||||
expect(z.string().catch(cb).parse("test")).toBe("test");
|
||||
expect(isCalled).toEqual(false);
|
||||
});
|
||||
|
||||
test("basic catch async", async () => {
|
||||
const result = await z.string().catch("default").parseAsync(1243);
|
||||
expect(result).toBe("default");
|
||||
});
|
||||
|
||||
test("catch replace wrong types", () => {
|
||||
expect(z.string().catch("default").parse(true)).toBe("default");
|
||||
expect(z.string().catch("default").parse(true)).toBe("default");
|
||||
expect(z.string().catch("default").parse(15)).toBe("default");
|
||||
expect(z.string().catch("default").parse([])).toBe("default");
|
||||
expect(z.string().catch("default").parse(new Map())).toBe("default");
|
||||
expect(z.string().catch("default").parse(new Set())).toBe("default");
|
||||
expect(z.string().catch("default").parse({})).toBe("default");
|
||||
});
|
||||
|
||||
test("catch with transform", () => {
|
||||
const stringWithDefault = z
|
||||
.string()
|
||||
.transform((val) => val.toUpperCase())
|
||||
.catch("default");
|
||||
|
||||
expect(stringWithDefault.parse(undefined)).toBe("default");
|
||||
expect(stringWithDefault.parse(15)).toBe("default");
|
||||
expect(stringWithDefault).toBeInstanceOf(z.ZodCatch);
|
||||
expect(stringWithDefault.unwrap()).toBeInstanceOf(z.ZodPipe);
|
||||
expect(stringWithDefault.unwrap().in).toBeInstanceOf(z.ZodString);
|
||||
expect(stringWithDefault.unwrap().out).toBeInstanceOf(z.ZodTransform);
|
||||
|
||||
type inp = z.input<typeof stringWithDefault>;
|
||||
expectTypeOf<inp>().toEqualTypeOf<string>();
|
||||
type out = z.output<typeof stringWithDefault>;
|
||||
expectTypeOf<out>().toEqualTypeOf<string>();
|
||||
});
|
||||
|
||||
test("catch on existing optional", () => {
|
||||
const stringWithDefault = z.string().optional().catch("asdf");
|
||||
expect(stringWithDefault.parse(undefined)).toBe(undefined);
|
||||
expect(stringWithDefault.parse(15)).toBe("asdf");
|
||||
expect(stringWithDefault).toBeInstanceOf(z.ZodCatch);
|
||||
expect(stringWithDefault.unwrap()).toBeInstanceOf(z.ZodOptional);
|
||||
expect(stringWithDefault.unwrap().unwrap()).toBeInstanceOf(z.ZodString);
|
||||
|
||||
type inp = z.input<typeof stringWithDefault>;
|
||||
expectTypeOf<inp>().toEqualTypeOf<string | undefined>();
|
||||
type out = z.output<typeof stringWithDefault>;
|
||||
expectTypeOf<out>().toEqualTypeOf<string | undefined>();
|
||||
});
|
||||
|
||||
test("optional on catch", () => {
|
||||
const stringWithDefault = z.string().catch("asdf").optional();
|
||||
|
||||
type inp = z.input<typeof stringWithDefault>;
|
||||
expectTypeOf<inp>().toEqualTypeOf<string | undefined>();
|
||||
type out = z.output<typeof stringWithDefault>;
|
||||
expectTypeOf<out>().toEqualTypeOf<string | undefined>();
|
||||
});
|
||||
|
||||
test("complex chain example", () => {
|
||||
const complex = z
|
||||
.string()
|
||||
.catch("asdf")
|
||||
.transform((val) => `${val}!`)
|
||||
.transform((val) => val.toUpperCase())
|
||||
.catch("qwer")
|
||||
.unwrap()
|
||||
.optional()
|
||||
.catch("asdfasdf");
|
||||
|
||||
expect(complex.parse("qwer")).toBe("QWER!");
|
||||
expect(complex.parse(15)).toBe("ASDF!");
|
||||
expect(complex.parse(true)).toBe("ASDF!");
|
||||
});
|
||||
|
||||
test("removeCatch", () => {
|
||||
const stringWithRemovedDefault = z.string().catch("asdf").unwrap();
|
||||
|
||||
type out = z.output<typeof stringWithRemovedDefault>;
|
||||
expectTypeOf<out>().toEqualTypeOf<string>();
|
||||
});
|
||||
|
||||
test("nested", () => {
|
||||
const inner = z.string().catch("asdf");
|
||||
const outer = z.object({ inner }).catch({
|
||||
inner: "asdf",
|
||||
});
|
||||
type input = z.input<typeof outer>;
|
||||
expectTypeOf<input>().toEqualTypeOf<{ inner: string }>();
|
||||
type out = z.output<typeof outer>;
|
||||
|
||||
expectTypeOf<out>().toEqualTypeOf<{ inner: string }>();
|
||||
expect(outer.parse(undefined)).toEqual({ inner: "asdf" });
|
||||
expect(outer.parse({})).toEqual({ inner: "asdf" });
|
||||
expect(outer.parse({ inner: undefined })).toEqual({ inner: "asdf" });
|
||||
});
|
||||
|
||||
test("chained catch", () => {
|
||||
const stringWithDefault = z.string().catch("inner").catch("outer");
|
||||
const result = stringWithDefault.parse(undefined);
|
||||
expect(result).toEqual("inner");
|
||||
const resultDiff = stringWithDefault.parse(5);
|
||||
expect(resultDiff).toEqual("inner");
|
||||
});
|
||||
|
||||
test("native enum", () => {
|
||||
enum Fruits {
|
||||
apple = "apple",
|
||||
orange = "orange",
|
||||
}
|
||||
|
||||
const schema = z.object({
|
||||
fruit: z.nativeEnum(Fruits).catch(Fruits.apple),
|
||||
});
|
||||
|
||||
// Absent keys flow through to the catch handler.
|
||||
expect(schema.parse({})).toEqual({ fruit: Fruits.apple });
|
||||
expect(schema.parse({}, { jitless: true })).toEqual({ fruit: Fruits.apple });
|
||||
expect(schema.parse({ fruit: 15 })).toEqual({ fruit: Fruits.apple });
|
||||
});
|
||||
|
||||
test("enum", () => {
|
||||
const schema = z.object({
|
||||
fruit: z.enum(["apple", "orange"]).catch("apple"),
|
||||
});
|
||||
|
||||
expect(schema.parse({})).toEqual({ fruit: "apple" });
|
||||
expect(schema.parse({}, { jitless: true })).toEqual({ fruit: "apple" });
|
||||
expect(schema.parse({ fruit: true })).toEqual({ fruit: "apple" });
|
||||
expect(schema.parse({ fruit: 15 })).toEqual({ fruit: "apple" });
|
||||
});
|
||||
|
||||
test("reported issues with nested usage", () => {
|
||||
const schema = z.object({
|
||||
string: z.string(),
|
||||
obj: z.object({
|
||||
sub: z.object({
|
||||
lit: z.literal("a"),
|
||||
subCatch: z.number().catch(23),
|
||||
}),
|
||||
midCatch: z.number().catch(42),
|
||||
}),
|
||||
number: z.number().catch(0),
|
||||
bool: z.boolean(),
|
||||
});
|
||||
|
||||
try {
|
||||
schema.parse({
|
||||
string: {},
|
||||
obj: {
|
||||
sub: {
|
||||
lit: "b",
|
||||
subCatch: "24",
|
||||
},
|
||||
midCatch: 444,
|
||||
},
|
||||
number: "",
|
||||
bool: "yes",
|
||||
});
|
||||
} catch (error) {
|
||||
const issues = (error as z.ZodError).issues;
|
||||
|
||||
expect(issues.length).toEqual(3);
|
||||
expect(issues).toMatchInlineSnapshot(`
|
||||
[
|
||||
{
|
||||
"code": "invalid_type",
|
||||
"expected": "string",
|
||||
"message": "Invalid input: expected string, received object",
|
||||
"path": [
|
||||
"string",
|
||||
],
|
||||
},
|
||||
{
|
||||
"code": "invalid_value",
|
||||
"message": "Invalid input: expected "a"",
|
||||
"path": [
|
||||
"obj",
|
||||
"sub",
|
||||
"lit",
|
||||
],
|
||||
"values": [
|
||||
"a",
|
||||
],
|
||||
},
|
||||
{
|
||||
"code": "invalid_type",
|
||||
"expected": "boolean",
|
||||
"message": "Invalid input: expected boolean, received string",
|
||||
"path": [
|
||||
"bool",
|
||||
],
|
||||
},
|
||||
]
|
||||
`);
|
||||
// expect(issues[0].message).toMatch("string");
|
||||
// expect(issues[1].message).toMatch("literal");
|
||||
// expect(issues[2].message).toMatch("boolean");
|
||||
}
|
||||
});
|
||||
|
||||
test("catch error", () => {
|
||||
const schema = z.object({
|
||||
age: z.number(),
|
||||
name: z.string().catch((ctx) => {
|
||||
ctx.issues;
|
||||
// issues = ctx.issues;
|
||||
|
||||
return "John Doe";
|
||||
}),
|
||||
});
|
||||
|
||||
const result = schema.safeParse({
|
||||
age: null,
|
||||
name: null,
|
||||
});
|
||||
|
||||
expect(result.success).toEqual(false);
|
||||
expect(result.error!).toMatchInlineSnapshot(`
|
||||
[ZodError: [
|
||||
{
|
||||
"expected": "number",
|
||||
"code": "invalid_type",
|
||||
"path": [
|
||||
"age"
|
||||
],
|
||||
"message": "Invalid input: expected number, received null"
|
||||
}
|
||||
]]
|
||||
`);
|
||||
});
|
||||
|
||||
test("ctx.input", () => {
|
||||
const schema = z.string().catch((ctx) => {
|
||||
return String(ctx.input);
|
||||
});
|
||||
|
||||
expect(schema.parse(123)).toEqual("123");
|
||||
});
|
||||
|
||||
test("direction-aware catch", () => {
|
||||
const schema = z.string().catch("fallback");
|
||||
|
||||
// Forward direction (regular parse): catch should be applied
|
||||
expect(schema.parse(123)).toBe("fallback");
|
||||
|
||||
// Reverse direction (encode): catch should NOT be applied, invalid value should fail validation
|
||||
expect(z.safeEncode(schema, 123 as any)).toMatchInlineSnapshot(`
|
||||
{
|
||||
"error": [ZodError: [
|
||||
{
|
||||
"expected": "string",
|
||||
"code": "invalid_type",
|
||||
"path": [],
|
||||
"message": "Invalid input: expected string, received number"
|
||||
}
|
||||
]],
|
||||
"success": false,
|
||||
}
|
||||
`);
|
||||
|
||||
// But valid values should still work in reverse
|
||||
expect(z.encode(schema, "world")).toBe("world");
|
||||
});
|
||||
|
||||
test("optional clobbers catch through pipe boundaries", () => {
|
||||
expect(
|
||||
z
|
||||
.string()
|
||||
.catch("X")
|
||||
.transform((s) => s + "!")
|
||||
.optional()
|
||||
.parse(undefined)
|
||||
).toBeUndefined();
|
||||
expect(z.string().catch("X").pipe(z.string()).optional().parse(undefined)).toBeUndefined();
|
||||
expect(
|
||||
z
|
||||
.string()
|
||||
.catch("X")
|
||||
.transform((s) => s + "!")
|
||||
.transform((s) => s.toLowerCase())
|
||||
.optional()
|
||||
.parse(undefined)
|
||||
).toBeUndefined();
|
||||
expect(
|
||||
z
|
||||
.object({
|
||||
a: z
|
||||
.string()
|
||||
.catch("X")
|
||||
.transform((s) => s + "!")
|
||||
.optional(),
|
||||
})
|
||||
.parse({})
|
||||
).toEqual({});
|
||||
|
||||
expect(
|
||||
z
|
||||
.string()
|
||||
.catch("X")
|
||||
.transform((s) => s + "!")
|
||||
.parse("hi")
|
||||
).toBe("hi!");
|
||||
expect(
|
||||
z
|
||||
.string()
|
||||
.catch("X")
|
||||
.transform((s) => s + "!")
|
||||
.parse(123)
|
||||
).toBe("X!");
|
||||
});
|
||||
@@ -0,0 +1,7 @@
|
||||
import type { TSESTree } from '@typescript-eslint/utils';
|
||||
/**
|
||||
* Tests if a node appears at the beginning of an ancestor ExpressionStatement node.
|
||||
* @param node The node to check.
|
||||
* @returns Whether the node appears at the beginning of an ancestor ExpressionStatement node.
|
||||
*/
|
||||
export declare function isStartOfExpressionStatement(node: TSESTree.Node): boolean;
|
||||
@@ -0,0 +1,30 @@
|
||||
import { URL } from 'node:url'
|
||||
import Pool from './pool'
|
||||
import Dispatcher from './dispatcher'
|
||||
import TClientStats from './client-stats'
|
||||
import TPoolStats from './pool-stats'
|
||||
|
||||
export default Agent
|
||||
|
||||
declare class Agent extends Dispatcher {
|
||||
constructor (opts?: Agent.Options)
|
||||
/** `true` after `dispatcher.close()` has been called. */
|
||||
closed: boolean
|
||||
/** `true` after `dispatcher.destroyed()` has been called or `dispatcher.close()` has been called and the dispatcher shutdown has completed. */
|
||||
destroyed: boolean
|
||||
/** Dispatches a request. */
|
||||
dispatch (options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandler): boolean
|
||||
/** Aggregate stats for a Agent by origin. */
|
||||
readonly stats: Record<string, TClientStats | TPoolStats>
|
||||
}
|
||||
|
||||
declare namespace Agent {
|
||||
export interface Options extends Pool.Options {
|
||||
/** Default: `(origin, opts) => new Pool(origin, opts)`. */
|
||||
factory?(origin: string | URL, opts: Object): Dispatcher;
|
||||
maxOrigins?: number
|
||||
}
|
||||
|
||||
export interface DispatchOptions extends Dispatcher.DispatchOptions {
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,394 @@
|
||||
import type { StrictEqualUsingTSInternalIdenticalToOperator, IsNever, UnionToIntersection, UnionToTuple } from './utils';
|
||||
/**
|
||||
* The simple(ish) way to get overload info from a function
|
||||
* {@linkcode FunctionType}. Recent versions of TypeScript will match any
|
||||
* function against a generic 10-overload type, filling in slots with
|
||||
* duplicates of the function. So, we can just match against a single type
|
||||
* and get all the overloads.
|
||||
*
|
||||
* For older versions of TypeScript, we'll need to painstakingly do
|
||||
* ten separate matches.
|
||||
*/
|
||||
export type TSPost53OverloadsInfoUnion<FunctionType> = FunctionType extends {
|
||||
(...args: infer A1): infer R1;
|
||||
(...args: infer A2): infer R2;
|
||||
(...args: infer A3): infer R3;
|
||||
(...args: infer A4): infer R4;
|
||||
(...args: infer A5): infer R5;
|
||||
(...args: infer A6): infer R6;
|
||||
(...args: infer A7): infer R7;
|
||||
(...args: infer A8): infer R8;
|
||||
(...args: infer A9): infer R9;
|
||||
(...args: infer A10): infer R10;
|
||||
} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) | ((...p: A7) => R7) | ((...p: A8) => R8) | ((...p: A9) => R9) | ((...p: A10) => R10) : never;
|
||||
/**
|
||||
* A function with `unknown` parameters and return type.
|
||||
*/
|
||||
export type UnknownFunction = (...args: unknown[]) => unknown;
|
||||
/**
|
||||
* `true` iff {@linkcode FunctionType} is
|
||||
* equivalent to `(...args: unknown[]) => unknown`,
|
||||
* which is what an overload variant looks like for a non-existent overload.
|
||||
* This is useful because older versions of TypeScript end up with
|
||||
* 9 "useless" overloads and one real one for parameterless/generic functions.
|
||||
*
|
||||
* @see {@link https://github.com/microsoft/TypeScript/issues/28867 | Related}
|
||||
*/
|
||||
export type IsUselessOverloadInfo<FunctionType> = StrictEqualUsingTSInternalIdenticalToOperator<FunctionType, UnknownFunction>;
|
||||
/**
|
||||
* Old versions of TypeScript can sometimes seem to refuse to separate out
|
||||
* union members unless you put them each in a pointless tuple and add an
|
||||
* extra `infer X` expression. There may be a better way to work around this
|
||||
* problem, but since it's not a problem in newer versions of TypeScript,
|
||||
* it's not a priority right now.
|
||||
*/
|
||||
export type Tuplify<Union> = Union extends infer X ? [X] : never;
|
||||
/**
|
||||
* For older versions of TypeScript, we need two separate workarounds
|
||||
* to get overload info. First, we need need to use
|
||||
* {@linkcode DecreasingOverloadsInfoUnion} to get the overload info for
|
||||
* functions with 1-10 overloads. Then, we need to filter out the
|
||||
* "useless" overloads that are present in older versions of TypeScript,
|
||||
* for parameterless functions. To do this we use
|
||||
* {@linkcode IsUselessOverloadInfo} to remove useless overloads.
|
||||
*
|
||||
* @see {@link https://github.com/microsoft/TypeScript/issues/28867 | Related}
|
||||
*/
|
||||
export type TSPre53OverloadsInfoUnion<FunctionType> = Tuplify<DecreasingOverloadsInfoUnion<FunctionType>> extends infer Tup ? Tup extends [infer Fn] ? IsUselessOverloadInfo<Fn> extends true ? never : Fn : never : never;
|
||||
/**
|
||||
* For versions of TypeScript below 5.3, we need to check for 10 overloads,
|
||||
* then 9, then 8, etc., to get a union of the overload variants.
|
||||
*/
|
||||
export type DecreasingOverloadsInfoUnion<F> = F extends {
|
||||
(...args: infer A1): infer R1;
|
||||
(...args: infer A2): infer R2;
|
||||
(...args: infer A3): infer R3;
|
||||
(...args: infer A4): infer R4;
|
||||
(...args: infer A5): infer R5;
|
||||
(...args: infer A6): infer R6;
|
||||
(...args: infer A7): infer R7;
|
||||
(...args: infer A8): infer R8;
|
||||
(...args: infer A9): infer R9;
|
||||
(...args: infer A10): infer R10;
|
||||
} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) | ((...p: A7) => R7) | ((...p: A8) => R8) | ((...p: A9) => R9) | ((...p: A10) => R10) : F extends {
|
||||
(...args: infer A1): infer R1;
|
||||
(...args: infer A2): infer R2;
|
||||
(...args: infer A3): infer R3;
|
||||
(...args: infer A4): infer R4;
|
||||
(...args: infer A5): infer R5;
|
||||
(...args: infer A6): infer R6;
|
||||
(...args: infer A7): infer R7;
|
||||
(...args: infer A8): infer R8;
|
||||
(...args: infer A9): infer R9;
|
||||
} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) | ((...p: A7) => R7) | ((...p: A8) => R8) | ((...p: A9) => R9) : F extends {
|
||||
(...args: infer A1): infer R1;
|
||||
(...args: infer A2): infer R2;
|
||||
(...args: infer A3): infer R3;
|
||||
(...args: infer A4): infer R4;
|
||||
(...args: infer A5): infer R5;
|
||||
(...args: infer A6): infer R6;
|
||||
(...args: infer A7): infer R7;
|
||||
(...args: infer A8): infer R8;
|
||||
} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) | ((...p: A7) => R7) | ((...p: A8) => R8) : F extends {
|
||||
(...args: infer A1): infer R1;
|
||||
(...args: infer A2): infer R2;
|
||||
(...args: infer A3): infer R3;
|
||||
(...args: infer A4): infer R4;
|
||||
(...args: infer A5): infer R5;
|
||||
(...args: infer A6): infer R6;
|
||||
(...args: infer A7): infer R7;
|
||||
} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) | ((...p: A7) => R7) : F extends {
|
||||
(...args: infer A1): infer R1;
|
||||
(...args: infer A2): infer R2;
|
||||
(...args: infer A3): infer R3;
|
||||
(...args: infer A4): infer R4;
|
||||
(...args: infer A5): infer R5;
|
||||
(...args: infer A6): infer R6;
|
||||
} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) : F extends {
|
||||
(...args: infer A1): infer R1;
|
||||
(...args: infer A2): infer R2;
|
||||
(...args: infer A3): infer R3;
|
||||
(...args: infer A4): infer R4;
|
||||
(...args: infer A5): infer R5;
|
||||
} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) : F extends {
|
||||
(...args: infer A1): infer R1;
|
||||
(...args: infer A2): infer R2;
|
||||
(...args: infer A3): infer R3;
|
||||
(...args: infer A4): infer R4;
|
||||
} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) : F extends {
|
||||
(...args: infer A1): infer R1;
|
||||
(...args: infer A2): infer R2;
|
||||
(...args: infer A3): infer R3;
|
||||
} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) : F extends {
|
||||
(...args: infer A1): infer R1;
|
||||
(...args: infer A2): infer R2;
|
||||
} ? ((...p: A1) => R1) | ((...p: A2) => R2) : F extends (...args: infer A1) => infer R1 ? ((...p: A1) => R1) : never;
|
||||
/**
|
||||
* Get a union of overload variants for a function {@linkcode FunctionType}.
|
||||
* Does a check for whether we can do the one-shot
|
||||
* 10-overload matcher (which works for ts\>5.3), and if not,
|
||||
* falls back to the more complicated utility.
|
||||
*/
|
||||
export type OverloadsInfoUnion<FunctionType> = IsNever<TSPost53OverloadsInfoUnion<(a: 1) => 2>> extends true ? TSPre53OverloadsInfoUnion<FunctionType> : TSPost53OverloadsInfoUnion<FunctionType>;
|
||||
/**
|
||||
* Allows inferring any function using the `infer` keyword.
|
||||
*/
|
||||
export type InferFunctionType<FunctionType extends (...args: any) => any> = FunctionType;
|
||||
/**
|
||||
* A union type of the parameters allowed for any
|
||||
* overload of function {@linkcode FunctionType}.
|
||||
*/
|
||||
export type OverloadParameters<FunctionType> = OverloadsInfoUnion<FunctionType> extends InferFunctionType<infer Fn> ? Parameters<Fn> : never;
|
||||
/**
|
||||
* A union type of the return types for any overload of
|
||||
* function {@linkcode FunctionType}.
|
||||
*/
|
||||
export type OverloadReturnTypes<FunctionType> = OverloadsInfoUnion<FunctionType> extends InferFunctionType<infer Fn> ? ReturnType<Fn> : never;
|
||||
/**
|
||||
* Like {@linkcode TSPost53OverloadsInfoUnion} but extracts only the
|
||||
* `this` parameter types, using `(this: infer T, ...)` to preserve `this`
|
||||
* before it gets stripped.
|
||||
*
|
||||
* @template FunctionType - the function type to extract `this` parameter types from.
|
||||
*/
|
||||
export type TSPost53OverloadThisParameterTypes<FunctionType> = FunctionType extends {
|
||||
(this: infer T1, ...args: any[]): any;
|
||||
(this: infer T2, ...args: any[]): any;
|
||||
(this: infer T3, ...args: any[]): any;
|
||||
(this: infer T4, ...args: any[]): any;
|
||||
(this: infer T5, ...args: any[]): any;
|
||||
(this: infer T6, ...args: any[]): any;
|
||||
(this: infer T7, ...args: any[]): any;
|
||||
(this: infer T8, ...args: any[]): any;
|
||||
(this: infer T9, ...args: any[]): any;
|
||||
(this: infer T10, ...args: any[]): any;
|
||||
} ? T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9 | T10 : never;
|
||||
/**
|
||||
* Like {@linkcode DecreasingOverloadsInfoUnion} but preserves the
|
||||
* `this` parameter in each extracted function variant so that it can be
|
||||
* used for filtering and `this` type extraction.
|
||||
*
|
||||
* @template FunctionType - the function type to extract overload info from.
|
||||
*/
|
||||
export type DecreasingOverloadsInfoUnionWithThis<FunctionType> = FunctionType extends {
|
||||
(this: infer T1, ...args: infer A1): infer R1;
|
||||
(this: infer T2, ...args: infer A2): infer R2;
|
||||
(this: infer T3, ...args: infer A3): infer R3;
|
||||
(this: infer T4, ...args: infer A4): infer R4;
|
||||
(this: infer T5, ...args: infer A5): infer R5;
|
||||
(this: infer T6, ...args: infer A6): infer R6;
|
||||
(this: infer T7, ...args: infer A7): infer R7;
|
||||
(this: infer T8, ...args: infer A8): infer R8;
|
||||
(this: infer T9, ...args: infer A9): infer R9;
|
||||
(this: infer T10, ...args: infer A10): infer R10;
|
||||
} ? ((this: T1, ...args: A1) => R1) | ((this: T2, ...args: A2) => R2) | ((this: T3, ...args: A3) => R3) | ((this: T4, ...args: A4) => R4) | ((this: T5, ...args: A5) => R5) | ((this: T6, ...args: A6) => R6) | ((this: T7, ...args: A7) => R7) | ((this: T8, ...args: A8) => R8) | ((this: T9, ...args: A9) => R9) | ((this: T10, ...args: A10) => R10) : FunctionType extends {
|
||||
(this: infer T1, ...args: infer A1): infer R1;
|
||||
(this: infer T2, ...args: infer A2): infer R2;
|
||||
(this: infer T3, ...args: infer A3): infer R3;
|
||||
(this: infer T4, ...args: infer A4): infer R4;
|
||||
(this: infer T5, ...args: infer A5): infer R5;
|
||||
(this: infer T6, ...args: infer A6): infer R6;
|
||||
(this: infer T7, ...args: infer A7): infer R7;
|
||||
(this: infer T8, ...args: infer A8): infer R8;
|
||||
(this: infer T9, ...args: infer A9): infer R9;
|
||||
} ? ((this: T1, ...args: A1) => R1) | ((this: T2, ...args: A2) => R2) | ((this: T3, ...args: A3) => R3) | ((this: T4, ...args: A4) => R4) | ((this: T5, ...args: A5) => R5) | ((this: T6, ...args: A6) => R6) | ((this: T7, ...args: A7) => R7) | ((this: T8, ...args: A8) => R8) | ((this: T9, ...args: A9) => R9) : FunctionType extends {
|
||||
(this: infer T1, ...args: infer A1): infer R1;
|
||||
(this: infer T2, ...args: infer A2): infer R2;
|
||||
(this: infer T3, ...args: infer A3): infer R3;
|
||||
(this: infer T4, ...args: infer A4): infer R4;
|
||||
(this: infer T5, ...args: infer A5): infer R5;
|
||||
(this: infer T6, ...args: infer A6): infer R6;
|
||||
(this: infer T7, ...args: infer A7): infer R7;
|
||||
(this: infer T8, ...args: infer A8): infer R8;
|
||||
} ? ((this: T1, ...args: A1) => R1) | ((this: T2, ...args: A2) => R2) | ((this: T3, ...args: A3) => R3) | ((this: T4, ...args: A4) => R4) | ((this: T5, ...args: A5) => R5) | ((this: T6, ...args: A6) => R6) | ((this: T7, ...args: A7) => R7) | ((this: T8, ...args: A8) => R8) : FunctionType extends {
|
||||
(this: infer T1, ...args: infer A1): infer R1;
|
||||
(this: infer T2, ...args: infer A2): infer R2;
|
||||
(this: infer T3, ...args: infer A3): infer R3;
|
||||
(this: infer T4, ...args: infer A4): infer R4;
|
||||
(this: infer T5, ...args: infer A5): infer R5;
|
||||
(this: infer T6, ...args: infer A6): infer R6;
|
||||
(this: infer T7, ...args: infer A7): infer R7;
|
||||
} ? ((this: T1, ...args: A1) => R1) | ((this: T2, ...args: A2) => R2) | ((this: T3, ...args: A3) => R3) | ((this: T4, ...args: A4) => R4) | ((this: T5, ...args: A5) => R5) | ((this: T6, ...args: A6) => R6) | ((this: T7, ...args: A7) => R7) : FunctionType extends {
|
||||
(this: infer T1, ...args: infer A1): infer R1;
|
||||
(this: infer T2, ...args: infer A2): infer R2;
|
||||
(this: infer T3, ...args: infer A3): infer R3;
|
||||
(this: infer T4, ...args: infer A4): infer R4;
|
||||
(this: infer T5, ...args: infer A5): infer R5;
|
||||
(this: infer T6, ...args: infer A6): infer R6;
|
||||
} ? ((this: T1, ...args: A1) => R1) | ((this: T2, ...args: A2) => R2) | ((this: T3, ...args: A3) => R3) | ((this: T4, ...args: A4) => R4) | ((this: T5, ...args: A5) => R5) | ((this: T6, ...args: A6) => R6) : FunctionType extends {
|
||||
(this: infer T1, ...args: infer A1): infer R1;
|
||||
(this: infer T2, ...args: infer A2): infer R2;
|
||||
(this: infer T3, ...args: infer A3): infer R3;
|
||||
(this: infer T4, ...args: infer A4): infer R4;
|
||||
(this: infer T5, ...args: infer A5): infer R5;
|
||||
} ? ((this: T1, ...args: A1) => R1) | ((this: T2, ...args: A2) => R2) | ((this: T3, ...args: A3) => R3) | ((this: T4, ...args: A4) => R4) | ((this: T5, ...args: A5) => R5) : FunctionType extends {
|
||||
(this: infer T1, ...args: infer A1): infer R1;
|
||||
(this: infer T2, ...args: infer A2): infer R2;
|
||||
(this: infer T3, ...args: infer A3): infer R3;
|
||||
(this: infer T4, ...args: infer A4): infer R4;
|
||||
} ? ((this: T1, ...args: A1) => R1) | ((this: T2, ...args: A2) => R2) | ((this: T3, ...args: A3) => R3) | ((this: T4, ...args: A4) => R4) : FunctionType extends {
|
||||
(this: infer T1, ...args: infer A1): infer R1;
|
||||
(this: infer T2, ...args: infer A2): infer R2;
|
||||
(this: infer T3, ...args: infer A3): infer R3;
|
||||
} ? ((this: T1, ...args: A1) => R1) | ((this: T2, ...args: A2) => R2) | ((this: T3, ...args: A3) => R3) : FunctionType extends {
|
||||
(this: infer T1, ...args: infer A1): infer R1;
|
||||
(this: infer T2, ...args: infer A2): infer R2;
|
||||
} ? ((this: T1, ...args: A1) => R1) | ((this: T2, ...args: A2) => R2) : FunctionType extends (this: infer T1, ...args: infer A1) => infer R1 ? (this: T1, ...args: A1) => R1 : never;
|
||||
/**
|
||||
* Like {@linkcode TSPre53OverloadsInfoUnion} but extracts the
|
||||
* `this` parameter types, using
|
||||
* {@linkcode DecreasingOverloadsInfoUnionWithThis} to preserve `this`
|
||||
* through the filtering step.
|
||||
*
|
||||
* @template FunctionType - the function type to extract `this` parameter types from.
|
||||
*/
|
||||
export type TSPre53OverloadThisParameterTypes<FunctionType> = Tuplify<DecreasingOverloadsInfoUnionWithThis<FunctionType>> extends infer TupleType ? TupleType extends [infer OverloadedFunctionType] ? IsUselessOverloadInfo<OverloadedFunctionType> extends true ? never : OverloadedFunctionType extends (this: infer InferredThisType, ...args: any[]) => any ? InferredThisType : never : never : never;
|
||||
/**
|
||||
* A union type of the `this` parameter types for any overload of
|
||||
* function {@linkcode FunctionType}.
|
||||
*
|
||||
* @template FunctionType - the function type to extract `this` parameter types from.
|
||||
*/
|
||||
export type OverloadThisParameterTypes<FunctionType> = FunctionType extends (...args: any[]) => any ? IsNever<TSPost53OverloadsInfoUnion<(a: 1) => 2>> extends true ? TSPre53OverloadThisParameterTypes<FunctionType> : TSPost53OverloadThisParameterTypes<FunctionType> : ThisParameterType<FunctionType>;
|
||||
/**
|
||||
* Takes an overload variants {@linkcode Union},
|
||||
* produced from {@linkcode OverloadsInfoUnion} and rejects
|
||||
* the ones incompatible with parameters {@linkcode Args}.
|
||||
*/
|
||||
export type SelectOverloadsInfo<Union extends UnknownFunction, Args extends unknown[]> = Union extends InferFunctionType<infer Fn> ? (Args extends Parameters<Fn> ? Fn : never) : never;
|
||||
/**
|
||||
* Creates a new overload (an intersection type) from an existing one,
|
||||
* which only includes variant(s) which can accept
|
||||
* {@linkcode Args} as parameters.
|
||||
*/
|
||||
export type OverloadsNarrowedByParameters<FunctionType, Args extends OverloadParameters<FunctionType>> = UnionToIntersection<SelectOverloadsInfo<OverloadsInfoUnion<FunctionType>, Args>>;
|
||||
/**
|
||||
* The simple(ish) way to get overload info from a constructor
|
||||
* {@linkcode ConstructorType}. Recent versions of TypeScript will match any
|
||||
* constructor against a generic 10-overload type, filling in slots with
|
||||
* duplicates of the constructor. So, we can just match against a single type
|
||||
* and get all the overloads.
|
||||
*
|
||||
* For older versions of TypeScript,
|
||||
* we'll need to painstakingly do ten separate matches.
|
||||
*/
|
||||
export type TSPost53ConstructorOverloadsInfoUnion<ConstructorType> = ConstructorType extends {
|
||||
new (...args: infer A1): infer R1;
|
||||
new (...args: infer A2): infer R2;
|
||||
new (...args: infer A3): infer R3;
|
||||
new (...args: infer A4): infer R4;
|
||||
new (...args: infer A5): infer R5;
|
||||
new (...args: infer A6): infer R6;
|
||||
new (...args: infer A7): infer R7;
|
||||
new (...args: infer A8): infer R8;
|
||||
new (...args: infer A9): infer R9;
|
||||
new (...args: infer A10): infer R10;
|
||||
} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) | (new (...p: A7) => R7) | (new (...p: A8) => R8) | (new (...p: A9) => R9) | (new (...p: A10) => R10) : never;
|
||||
/**
|
||||
* A constructor function with `unknown` parameters and return type.
|
||||
*/
|
||||
export type UnknownConstructor = new (...args: unknown[]) => unknown;
|
||||
/**
|
||||
* Same as {@linkcode IsUselessOverloadInfo}, but for constructors.
|
||||
*/
|
||||
export type IsUselessConstructorOverloadInfo<FunctionType> = StrictEqualUsingTSInternalIdenticalToOperator<FunctionType, UnknownConstructor>;
|
||||
/**
|
||||
* For older versions of TypeScript, we need two separate workarounds to
|
||||
* get constructor overload info. First, we need need to use
|
||||
* {@linkcode DecreasingConstructorOverloadsInfoUnion} to get the overload
|
||||
* info for constructors with 1-10 overloads. Then, we need to filter out the
|
||||
* "useless" overloads that are present in older versions of TypeScript,
|
||||
* for parameterless constructors. To do this we use
|
||||
* {@linkcode IsUselessConstructorOverloadInfo} to remove useless overloads.
|
||||
*
|
||||
* @see {@link https://github.com/microsoft/TypeScript/issues/28867 | Related}
|
||||
*/
|
||||
export type TSPre53ConstructorOverloadsInfoUnion<ConstructorType> = Tuplify<DecreasingConstructorOverloadsInfoUnion<ConstructorType>> extends infer Tup ? Tup extends [infer Ctor] ? IsUselessConstructorOverloadInfo<Ctor> extends true ? never : Ctor : never : never;
|
||||
/**
|
||||
* For versions of TypeScript below 5.3, we need to check for 10 overloads,
|
||||
* then 9, then 8, etc., to get a union of the overload variants.
|
||||
*/
|
||||
export type DecreasingConstructorOverloadsInfoUnion<ConstructorType> = ConstructorType extends {
|
||||
new (...args: infer A1): infer R1;
|
||||
new (...args: infer A2): infer R2;
|
||||
new (...args: infer A3): infer R3;
|
||||
new (...args: infer A4): infer R4;
|
||||
new (...args: infer A5): infer R5;
|
||||
new (...args: infer A6): infer R6;
|
||||
new (...args: infer A7): infer R7;
|
||||
new (...args: infer A8): infer R8;
|
||||
new (...args: infer A9): infer R9;
|
||||
new (...args: infer A10): infer R10;
|
||||
} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) | (new (...p: A7) => R7) | (new (...p: A8) => R8) | (new (...p: A9) => R9) | (new (...p: A10) => R10) : ConstructorType extends {
|
||||
new (...args: infer A1): infer R1;
|
||||
new (...args: infer A2): infer R2;
|
||||
new (...args: infer A3): infer R3;
|
||||
new (...args: infer A4): infer R4;
|
||||
new (...args: infer A5): infer R5;
|
||||
new (...args: infer A6): infer R6;
|
||||
new (...args: infer A7): infer R7;
|
||||
new (...args: infer A8): infer R8;
|
||||
new (...args: infer A9): infer R9;
|
||||
} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) | (new (...p: A7) => R7) | (new (...p: A8) => R8) | (new (...p: A9) => R9) : ConstructorType extends {
|
||||
new (...args: infer A1): infer R1;
|
||||
new (...args: infer A2): infer R2;
|
||||
new (...args: infer A3): infer R3;
|
||||
new (...args: infer A4): infer R4;
|
||||
new (...args: infer A5): infer R5;
|
||||
new (...args: infer A6): infer R6;
|
||||
new (...args: infer A7): infer R7;
|
||||
new (...args: infer A8): infer R8;
|
||||
} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) | (new (...p: A7) => R7) | (new (...p: A8) => R8) : ConstructorType extends {
|
||||
new (...args: infer A1): infer R1;
|
||||
new (...args: infer A2): infer R2;
|
||||
new (...args: infer A3): infer R3;
|
||||
new (...args: infer A4): infer R4;
|
||||
new (...args: infer A5): infer R5;
|
||||
new (...args: infer A6): infer R6;
|
||||
new (...args: infer A7): infer R7;
|
||||
} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) | (new (...p: A7) => R7) : ConstructorType extends {
|
||||
new (...args: infer A1): infer R1;
|
||||
new (...args: infer A2): infer R2;
|
||||
new (...args: infer A3): infer R3;
|
||||
new (...args: infer A4): infer R4;
|
||||
new (...args: infer A5): infer R5;
|
||||
new (...args: infer A6): infer R6;
|
||||
} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) : ConstructorType extends {
|
||||
new (...args: infer A1): infer R1;
|
||||
new (...args: infer A2): infer R2;
|
||||
new (...args: infer A3): infer R3;
|
||||
new (...args: infer A4): infer R4;
|
||||
new (...args: infer A5): infer R5;
|
||||
} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) : ConstructorType extends {
|
||||
new (...args: infer A1): infer R1;
|
||||
new (...args: infer A2): infer R2;
|
||||
new (...args: infer A3): infer R3;
|
||||
new (...args: infer A4): infer R4;
|
||||
} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) : ConstructorType extends {
|
||||
new (...args: infer A1): infer R1;
|
||||
new (...args: infer A2): infer R2;
|
||||
new (...args: infer A3): infer R3;
|
||||
} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) : ConstructorType extends {
|
||||
new (...args: infer A1): infer R1;
|
||||
new (...args: infer A2): infer R2;
|
||||
} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) : ConstructorType extends new (...args: infer A1) => infer R1 ? (new (...p: A1) => R1) : never;
|
||||
/**
|
||||
* Get a union of overload variants for a constructor
|
||||
* {@linkcode ConstructorType}. Does a check for whether we can do the
|
||||
* one-shot 10-overload matcher (which works for ts\>5.3), and if not,
|
||||
* falls back to the more complicated utility.
|
||||
*/
|
||||
export type ConstructorOverloadsUnion<ConstructorType> = IsNever<TSPost53ConstructorOverloadsInfoUnion<new (a: 1) => any>> extends true ? TSPre53ConstructorOverloadsInfoUnion<ConstructorType> : TSPost53ConstructorOverloadsInfoUnion<ConstructorType>;
|
||||
/**
|
||||
* Allows inferring any constructor using the `infer` keyword.
|
||||
*/
|
||||
export type InferConstructor<ConstructorType extends new (...args: any) => any> = ConstructorType;
|
||||
/**
|
||||
* A union type of the parameters allowed for any overload
|
||||
* of constructor {@linkcode ConstructorType}.
|
||||
*/
|
||||
export type ConstructorOverloadParameters<ConstructorType> = ConstructorOverloadsUnion<ConstructorType> extends InferConstructor<infer Ctor> ? ConstructorParameters<Ctor> : never;
|
||||
/**
|
||||
* Calculates the number of overloads for a given function type.
|
||||
*/
|
||||
export type NumOverloads<FunctionType> = UnionToTuple<OverloadsInfoUnion<FunctionType>>['length'];
|
||||
@@ -0,0 +1,114 @@
|
||||
/*! *****************************************************************************
|
||||
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.
|
||||
***************************************************************************** */
|
||||
|
||||
|
||||
interface Array<T> {
|
||||
/**
|
||||
* Determines whether an array includes a certain element, returning true or false as appropriate.
|
||||
* @param searchElement The element to search for.
|
||||
* @param fromIndex The position in this array at which to begin searching for searchElement.
|
||||
*/
|
||||
includes(searchElement: T, fromIndex?: number): boolean;
|
||||
}
|
||||
|
||||
interface ReadonlyArray<T> {
|
||||
/**
|
||||
* Determines whether an array includes a certain element, returning true or false as appropriate.
|
||||
* @param searchElement The element to search for.
|
||||
* @param fromIndex The position in this array at which to begin searching for searchElement.
|
||||
*/
|
||||
includes(searchElement: T, fromIndex?: number): boolean;
|
||||
}
|
||||
|
||||
interface Int8Array<TArrayBuffer extends ArrayBufferLike> {
|
||||
/**
|
||||
* Determines whether an array includes a certain element, returning true or false as appropriate.
|
||||
* @param searchElement The element to search for.
|
||||
* @param fromIndex The position in this array at which to begin searching for searchElement.
|
||||
*/
|
||||
includes(searchElement: number, fromIndex?: number): boolean;
|
||||
}
|
||||
|
||||
interface Uint8Array<TArrayBuffer extends ArrayBufferLike> {
|
||||
/**
|
||||
* Determines whether an array includes a certain element, returning true or false as appropriate.
|
||||
* @param searchElement The element to search for.
|
||||
* @param fromIndex The position in this array at which to begin searching for searchElement.
|
||||
*/
|
||||
includes(searchElement: number, fromIndex?: number): boolean;
|
||||
}
|
||||
|
||||
interface Uint8ClampedArray<TArrayBuffer extends ArrayBufferLike> {
|
||||
/**
|
||||
* Determines whether an array includes a certain element, returning true or false as appropriate.
|
||||
* @param searchElement The element to search for.
|
||||
* @param fromIndex The position in this array at which to begin searching for searchElement.
|
||||
*/
|
||||
includes(searchElement: number, fromIndex?: number): boolean;
|
||||
}
|
||||
|
||||
interface Int16Array<TArrayBuffer extends ArrayBufferLike> {
|
||||
/**
|
||||
* Determines whether an array includes a certain element, returning true or false as appropriate.
|
||||
* @param searchElement The element to search for.
|
||||
* @param fromIndex The position in this array at which to begin searching for searchElement.
|
||||
*/
|
||||
includes(searchElement: number, fromIndex?: number): boolean;
|
||||
}
|
||||
|
||||
interface Uint16Array<TArrayBuffer extends ArrayBufferLike> {
|
||||
/**
|
||||
* Determines whether an array includes a certain element, returning true or false as appropriate.
|
||||
* @param searchElement The element to search for.
|
||||
* @param fromIndex The position in this array at which to begin searching for searchElement.
|
||||
*/
|
||||
includes(searchElement: number, fromIndex?: number): boolean;
|
||||
}
|
||||
|
||||
interface Int32Array<TArrayBuffer extends ArrayBufferLike> {
|
||||
/**
|
||||
* Determines whether an array includes a certain element, returning true or false as appropriate.
|
||||
* @param searchElement The element to search for.
|
||||
* @param fromIndex The position in this array at which to begin searching for searchElement.
|
||||
*/
|
||||
includes(searchElement: number, fromIndex?: number): boolean;
|
||||
}
|
||||
|
||||
interface Uint32Array<TArrayBuffer extends ArrayBufferLike> {
|
||||
/**
|
||||
* Determines whether an array includes a certain element, returning true or false as appropriate.
|
||||
* @param searchElement The element to search for.
|
||||
* @param fromIndex The position in this array at which to begin searching for searchElement.
|
||||
*/
|
||||
includes(searchElement: number, fromIndex?: number): boolean;
|
||||
}
|
||||
|
||||
interface Float32Array<TArrayBuffer extends ArrayBufferLike> {
|
||||
/**
|
||||
* Determines whether an array includes a certain element, returning true or false as appropriate.
|
||||
* @param searchElement The element to search for.
|
||||
* @param fromIndex The position in this array at which to begin searching for searchElement.
|
||||
*/
|
||||
includes(searchElement: number, fromIndex?: number): boolean;
|
||||
}
|
||||
|
||||
interface Float64Array<TArrayBuffer extends ArrayBufferLike> {
|
||||
/**
|
||||
* Determines whether an array includes a certain element, returning true or false as appropriate.
|
||||
* @param searchElement The element to search for.
|
||||
* @param fromIndex The position in this array at which to begin searching for searchElement.
|
||||
*/
|
||||
includes(searchElement: number, fromIndex?: number): boolean;
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
'use strict'
|
||||
|
||||
process.env.TZ = 'UTC'
|
||||
|
||||
const { test } = require('node:test')
|
||||
const isValidDate = require('./is-valid-date')
|
||||
|
||||
test('returns true for valid dates', t => {
|
||||
t.assert.strictEqual(isValidDate(new Date()), true)
|
||||
})
|
||||
|
||||
test('returns false for non-dates and invalid dates', t => {
|
||||
t.plan(2)
|
||||
t.assert.strictEqual(isValidDate('20210621'), false)
|
||||
t.assert.strictEqual(isValidDate(new Date('2021-41-99')), false)
|
||||
})
|
||||
@@ -0,0 +1,232 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.scrypt = scrypt;
|
||||
exports.scryptAsync = scryptAsync;
|
||||
/**
|
||||
* RFC 7914 Scrypt KDF. Can be used to create a key from password and salt.
|
||||
* @module
|
||||
*/
|
||||
const pbkdf2_ts_1 = require("./pbkdf2.js");
|
||||
const sha2_ts_1 = require("./sha2.js");
|
||||
// prettier-ignore
|
||||
const utils_ts_1 = require("./utils.js");
|
||||
// The main Scrypt loop: uses Salsa extensively.
|
||||
// Six versions of the function were tried, this is the fastest one.
|
||||
// prettier-ignore
|
||||
function XorAndSalsa(prev, pi, input, ii, out, oi) {
|
||||
// Based on https://cr.yp.to/salsa20.html
|
||||
// Xor blocks
|
||||
let y00 = prev[pi++] ^ input[ii++], y01 = prev[pi++] ^ input[ii++];
|
||||
let y02 = prev[pi++] ^ input[ii++], y03 = prev[pi++] ^ input[ii++];
|
||||
let y04 = prev[pi++] ^ input[ii++], y05 = prev[pi++] ^ input[ii++];
|
||||
let y06 = prev[pi++] ^ input[ii++], y07 = prev[pi++] ^ input[ii++];
|
||||
let y08 = prev[pi++] ^ input[ii++], y09 = prev[pi++] ^ input[ii++];
|
||||
let y10 = prev[pi++] ^ input[ii++], y11 = prev[pi++] ^ input[ii++];
|
||||
let y12 = prev[pi++] ^ input[ii++], y13 = prev[pi++] ^ input[ii++];
|
||||
let y14 = prev[pi++] ^ input[ii++], y15 = prev[pi++] ^ input[ii++];
|
||||
// Save state to temporary variables (salsa)
|
||||
let x00 = y00, x01 = y01, x02 = y02, x03 = y03, x04 = y04, x05 = y05, x06 = y06, x07 = y07, x08 = y08, x09 = y09, x10 = y10, x11 = y11, x12 = y12, x13 = y13, x14 = y14, x15 = y15;
|
||||
// Main loop (salsa)
|
||||
for (let i = 0; i < 8; i += 2) {
|
||||
x04 ^= (0, utils_ts_1.rotl)(x00 + x12 | 0, 7);
|
||||
x08 ^= (0, utils_ts_1.rotl)(x04 + x00 | 0, 9);
|
||||
x12 ^= (0, utils_ts_1.rotl)(x08 + x04 | 0, 13);
|
||||
x00 ^= (0, utils_ts_1.rotl)(x12 + x08 | 0, 18);
|
||||
x09 ^= (0, utils_ts_1.rotl)(x05 + x01 | 0, 7);
|
||||
x13 ^= (0, utils_ts_1.rotl)(x09 + x05 | 0, 9);
|
||||
x01 ^= (0, utils_ts_1.rotl)(x13 + x09 | 0, 13);
|
||||
x05 ^= (0, utils_ts_1.rotl)(x01 + x13 | 0, 18);
|
||||
x14 ^= (0, utils_ts_1.rotl)(x10 + x06 | 0, 7);
|
||||
x02 ^= (0, utils_ts_1.rotl)(x14 + x10 | 0, 9);
|
||||
x06 ^= (0, utils_ts_1.rotl)(x02 + x14 | 0, 13);
|
||||
x10 ^= (0, utils_ts_1.rotl)(x06 + x02 | 0, 18);
|
||||
x03 ^= (0, utils_ts_1.rotl)(x15 + x11 | 0, 7);
|
||||
x07 ^= (0, utils_ts_1.rotl)(x03 + x15 | 0, 9);
|
||||
x11 ^= (0, utils_ts_1.rotl)(x07 + x03 | 0, 13);
|
||||
x15 ^= (0, utils_ts_1.rotl)(x11 + x07 | 0, 18);
|
||||
x01 ^= (0, utils_ts_1.rotl)(x00 + x03 | 0, 7);
|
||||
x02 ^= (0, utils_ts_1.rotl)(x01 + x00 | 0, 9);
|
||||
x03 ^= (0, utils_ts_1.rotl)(x02 + x01 | 0, 13);
|
||||
x00 ^= (0, utils_ts_1.rotl)(x03 + x02 | 0, 18);
|
||||
x06 ^= (0, utils_ts_1.rotl)(x05 + x04 | 0, 7);
|
||||
x07 ^= (0, utils_ts_1.rotl)(x06 + x05 | 0, 9);
|
||||
x04 ^= (0, utils_ts_1.rotl)(x07 + x06 | 0, 13);
|
||||
x05 ^= (0, utils_ts_1.rotl)(x04 + x07 | 0, 18);
|
||||
x11 ^= (0, utils_ts_1.rotl)(x10 + x09 | 0, 7);
|
||||
x08 ^= (0, utils_ts_1.rotl)(x11 + x10 | 0, 9);
|
||||
x09 ^= (0, utils_ts_1.rotl)(x08 + x11 | 0, 13);
|
||||
x10 ^= (0, utils_ts_1.rotl)(x09 + x08 | 0, 18);
|
||||
x12 ^= (0, utils_ts_1.rotl)(x15 + x14 | 0, 7);
|
||||
x13 ^= (0, utils_ts_1.rotl)(x12 + x15 | 0, 9);
|
||||
x14 ^= (0, utils_ts_1.rotl)(x13 + x12 | 0, 13);
|
||||
x15 ^= (0, utils_ts_1.rotl)(x14 + x13 | 0, 18);
|
||||
}
|
||||
// Write output (salsa)
|
||||
out[oi++] = (y00 + x00) | 0;
|
||||
out[oi++] = (y01 + x01) | 0;
|
||||
out[oi++] = (y02 + x02) | 0;
|
||||
out[oi++] = (y03 + x03) | 0;
|
||||
out[oi++] = (y04 + x04) | 0;
|
||||
out[oi++] = (y05 + x05) | 0;
|
||||
out[oi++] = (y06 + x06) | 0;
|
||||
out[oi++] = (y07 + x07) | 0;
|
||||
out[oi++] = (y08 + x08) | 0;
|
||||
out[oi++] = (y09 + x09) | 0;
|
||||
out[oi++] = (y10 + x10) | 0;
|
||||
out[oi++] = (y11 + x11) | 0;
|
||||
out[oi++] = (y12 + x12) | 0;
|
||||
out[oi++] = (y13 + x13) | 0;
|
||||
out[oi++] = (y14 + x14) | 0;
|
||||
out[oi++] = (y15 + x15) | 0;
|
||||
}
|
||||
function BlockMix(input, ii, out, oi, r) {
|
||||
// The block B is r 128-byte chunks (which is equivalent of 2r 64-byte chunks)
|
||||
let head = oi + 0;
|
||||
let tail = oi + 16 * r;
|
||||
for (let i = 0; i < 16; i++)
|
||||
out[tail + i] = input[ii + (2 * r - 1) * 16 + i]; // X ← B[2r−1]
|
||||
for (let i = 0; i < r; i++, head += 16, ii += 16) {
|
||||
// We write odd & even Yi at same time. Even: 0bXXXXX0 Odd: 0bXXXXX1
|
||||
XorAndSalsa(out, tail, input, ii, out, head); // head[i] = Salsa(blockIn[2*i] ^ tail[i-1])
|
||||
if (i > 0)
|
||||
tail += 16; // First iteration overwrites tmp value in tail
|
||||
XorAndSalsa(out, head, input, (ii += 16), out, tail); // tail[i] = Salsa(blockIn[2*i+1] ^ head[i])
|
||||
}
|
||||
}
|
||||
// Common prologue and epilogue for sync/async functions
|
||||
function scryptInit(password, salt, _opts) {
|
||||
// Maxmem - 1GB+1KB by default
|
||||
const opts = (0, utils_ts_1.checkOpts)({
|
||||
dkLen: 32,
|
||||
asyncTick: 10,
|
||||
maxmem: 1024 ** 3 + 1024,
|
||||
}, _opts);
|
||||
const { N, r, p, dkLen, asyncTick, maxmem, onProgress } = opts;
|
||||
(0, utils_ts_1.anumber)(N);
|
||||
(0, utils_ts_1.anumber)(r);
|
||||
(0, utils_ts_1.anumber)(p);
|
||||
(0, utils_ts_1.anumber)(dkLen);
|
||||
(0, utils_ts_1.anumber)(asyncTick);
|
||||
(0, utils_ts_1.anumber)(maxmem);
|
||||
if (onProgress !== undefined && typeof onProgress !== 'function')
|
||||
throw new Error('progressCb should be function');
|
||||
const blockSize = 128 * r;
|
||||
const blockSize32 = blockSize / 4;
|
||||
// Max N is 2^32 (Integrify is 32-bit). Real limit is 2^22: JS engines Uint8Array limit is 4GB in 2024.
|
||||
// Spec check `N >= 2^(blockSize / 8)` is not done for compat with popular libs,
|
||||
// which used incorrect r: 1, p: 8. Also, the check seems to be a spec error:
|
||||
// https://www.rfc-editor.org/errata_search.php?rfc=7914
|
||||
const pow32 = Math.pow(2, 32);
|
||||
if (N <= 1 || (N & (N - 1)) !== 0 || N > pow32) {
|
||||
throw new Error('Scrypt: N must be larger than 1, a power of 2, and less than 2^32');
|
||||
}
|
||||
if (p < 0 || p > ((pow32 - 1) * 32) / blockSize) {
|
||||
throw new Error('Scrypt: p must be a positive integer less than or equal to ((2^32 - 1) * 32) / (128 * r)');
|
||||
}
|
||||
if (dkLen < 0 || dkLen > (pow32 - 1) * 32) {
|
||||
throw new Error('Scrypt: dkLen should be positive integer less than or equal to (2^32 - 1) * 32');
|
||||
}
|
||||
const memUsed = blockSize * (N + p);
|
||||
if (memUsed > maxmem) {
|
||||
throw new Error('Scrypt: memused is bigger than maxMem. Expected 128 * r * (N + p) > maxmem of ' + maxmem);
|
||||
}
|
||||
// [B0...Bp−1] ← PBKDF2HMAC-SHA256(Passphrase, Salt, 1, blockSize*ParallelizationFactor)
|
||||
// Since it has only one iteration there is no reason to use async variant
|
||||
const B = (0, pbkdf2_ts_1.pbkdf2)(sha2_ts_1.sha256, password, salt, { c: 1, dkLen: blockSize * p });
|
||||
const B32 = (0, utils_ts_1.u32)(B);
|
||||
// Re-used between parallel iterations. Array(iterations) of B
|
||||
const V = (0, utils_ts_1.u32)(new Uint8Array(blockSize * N));
|
||||
const tmp = (0, utils_ts_1.u32)(new Uint8Array(blockSize));
|
||||
let blockMixCb = () => { };
|
||||
if (onProgress) {
|
||||
const totalBlockMix = 2 * N * p;
|
||||
// Invoke callback if progress changes from 10.01 to 10.02
|
||||
// Allows to draw smooth progress bar on up to 8K screen
|
||||
const callbackPer = Math.max(Math.floor(totalBlockMix / 10000), 1);
|
||||
let blockMixCnt = 0;
|
||||
blockMixCb = () => {
|
||||
blockMixCnt++;
|
||||
if (onProgress && (!(blockMixCnt % callbackPer) || blockMixCnt === totalBlockMix))
|
||||
onProgress(blockMixCnt / totalBlockMix);
|
||||
};
|
||||
}
|
||||
return { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb, asyncTick };
|
||||
}
|
||||
function scryptOutput(password, dkLen, B, V, tmp) {
|
||||
const res = (0, pbkdf2_ts_1.pbkdf2)(sha2_ts_1.sha256, password, B, { c: 1, dkLen });
|
||||
(0, utils_ts_1.clean)(B, V, tmp);
|
||||
return res;
|
||||
}
|
||||
/**
|
||||
* Scrypt KDF from RFC 7914.
|
||||
* @param password - pass
|
||||
* @param salt - salt
|
||||
* @param opts - parameters
|
||||
* - `N` is cpu/mem work factor (power of 2 e.g. 2**18)
|
||||
* - `r` is block size (8 is common), fine-tunes sequential memory read size and performance
|
||||
* - `p` is parallelization factor (1 is common)
|
||||
* - `dkLen` is output key length in bytes e.g. 32.
|
||||
* - `asyncTick` - (default: 10) max time in ms for which async function can block execution
|
||||
* - `maxmem` - (default: `1024 ** 3 + 1024` aka 1GB+1KB). A limit that the app could use for scrypt
|
||||
* - `onProgress` - callback function that would be executed for progress report
|
||||
* @returns Derived key
|
||||
* @example
|
||||
* scrypt('password', 'salt', { N: 2**18, r: 8, p: 1, dkLen: 32 });
|
||||
*/
|
||||
function scrypt(password, salt, opts) {
|
||||
const { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb } = scryptInit(password, salt, opts);
|
||||
(0, utils_ts_1.swap32IfBE)(B32);
|
||||
for (let pi = 0; pi < p; pi++) {
|
||||
const Pi = blockSize32 * pi;
|
||||
for (let i = 0; i < blockSize32; i++)
|
||||
V[i] = B32[Pi + i]; // V[0] = B[i]
|
||||
for (let i = 0, pos = 0; i < N - 1; i++) {
|
||||
BlockMix(V, pos, V, (pos += blockSize32), r); // V[i] = BlockMix(V[i-1]);
|
||||
blockMixCb();
|
||||
}
|
||||
BlockMix(V, (N - 1) * blockSize32, B32, Pi, r); // Process last element
|
||||
blockMixCb();
|
||||
for (let i = 0; i < N; i++) {
|
||||
// First u32 of the last 64-byte block (u32 is LE)
|
||||
const j = B32[Pi + blockSize32 - 16] % N; // j = Integrify(X) % iterations
|
||||
for (let k = 0; k < blockSize32; k++)
|
||||
tmp[k] = B32[Pi + k] ^ V[j * blockSize32 + k]; // tmp = B ^ V[j]
|
||||
BlockMix(tmp, 0, B32, Pi, r); // B = BlockMix(B ^ V[j])
|
||||
blockMixCb();
|
||||
}
|
||||
}
|
||||
(0, utils_ts_1.swap32IfBE)(B32);
|
||||
return scryptOutput(password, dkLen, B, V, tmp);
|
||||
}
|
||||
/**
|
||||
* Scrypt KDF from RFC 7914. Async version.
|
||||
* @example
|
||||
* await scryptAsync('password', 'salt', { N: 2**18, r: 8, p: 1, dkLen: 32 });
|
||||
*/
|
||||
async function scryptAsync(password, salt, opts) {
|
||||
const { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb, asyncTick } = scryptInit(password, salt, opts);
|
||||
(0, utils_ts_1.swap32IfBE)(B32);
|
||||
for (let pi = 0; pi < p; pi++) {
|
||||
const Pi = blockSize32 * pi;
|
||||
for (let i = 0; i < blockSize32; i++)
|
||||
V[i] = B32[Pi + i]; // V[0] = B[i]
|
||||
let pos = 0;
|
||||
await (0, utils_ts_1.asyncLoop)(N - 1, asyncTick, () => {
|
||||
BlockMix(V, pos, V, (pos += blockSize32), r); // V[i] = BlockMix(V[i-1]);
|
||||
blockMixCb();
|
||||
});
|
||||
BlockMix(V, (N - 1) * blockSize32, B32, Pi, r); // Process last element
|
||||
blockMixCb();
|
||||
await (0, utils_ts_1.asyncLoop)(N, asyncTick, () => {
|
||||
// First u32 of the last 64-byte block (u32 is LE)
|
||||
const j = B32[Pi + blockSize32 - 16] % N; // j = Integrify(X) % iterations
|
||||
for (let k = 0; k < blockSize32; k++)
|
||||
tmp[k] = B32[Pi + k] ^ V[j * blockSize32 + k]; // tmp = B ^ V[j]
|
||||
BlockMix(tmp, 0, B32, Pi, r); // B = BlockMix(B ^ V[j])
|
||||
blockMixCb();
|
||||
});
|
||||
}
|
||||
(0, utils_ts_1.swap32IfBE)(B32);
|
||||
return scryptOutput(password, dkLen, B, V, tmp);
|
||||
}
|
||||
//# sourceMappingURL=scrypt.js.map
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"signatureFlags.d.ts","sourceRoot":"","sources":["../../src/enums/signatureFlags.ts"],"names":[],"mappings":"AACA,eAAO,IAAI,cAAc,EAAE,GAAG,CAAC"}
|
||||
@@ -0,0 +1,17 @@
|
||||
"use strict";
|
||||
// THIS CODE WAS AUTOMATICALLY GENERATED
|
||||
// DO NOT EDIT THIS CODE BY HAND
|
||||
// RUN THE FOLLOWING COMMAND FROM THE WORKSPACE ROOT TO REGENERATE:
|
||||
// npx nx generate-lib repo
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.es2020_promise = void 0;
|
||||
const base_config_1 = require("./base-config");
|
||||
exports.es2020_promise = {
|
||||
libs: [],
|
||||
variables: [
|
||||
['PromiseFulfilledResult', base_config_1.TYPE],
|
||||
['PromiseRejectedResult', base_config_1.TYPE],
|
||||
['PromiseSettledResult', base_config_1.TYPE],
|
||||
['PromiseConstructor', base_config_1.TYPE],
|
||||
],
|
||||
};
|
||||
@@ -0,0 +1,36 @@
|
||||
/**
|
||||
* @typedef { import('estree').Node} Node
|
||||
* @typedef { import('./walker.js').WalkerContext} WalkerContext
|
||||
* @typedef {(
|
||||
* this: WalkerContext,
|
||||
* node: Node,
|
||||
* parent: Node | null,
|
||||
* key: string | number | symbol | null | undefined,
|
||||
* index: number | null | undefined
|
||||
* ) => Promise<void>} AsyncHandler
|
||||
*/
|
||||
export class AsyncWalker extends WalkerBase {
|
||||
/**
|
||||
*
|
||||
* @param {AsyncHandler} [enter]
|
||||
* @param {AsyncHandler} [leave]
|
||||
*/
|
||||
constructor(enter?: AsyncHandler | undefined, leave?: AsyncHandler | undefined);
|
||||
/** @type {AsyncHandler | undefined} */
|
||||
enter: AsyncHandler | undefined;
|
||||
/** @type {AsyncHandler | undefined} */
|
||||
leave: AsyncHandler | undefined;
|
||||
/**
|
||||
* @template {Node} Parent
|
||||
* @param {Node} node
|
||||
* @param {Parent | null} parent
|
||||
* @param {keyof Parent} [prop]
|
||||
* @param {number | null} [index]
|
||||
* @returns {Promise<Node | null>}
|
||||
*/
|
||||
visit<Parent extends import("estree").Node>(node: Node, parent: Parent | null, prop?: keyof Parent | undefined, index?: number | null | undefined): Promise<Node | null>;
|
||||
}
|
||||
export type Node = import('estree').Node;
|
||||
export type WalkerContext = import('./walker.js').WalkerContext;
|
||||
export type AsyncHandler = (this: WalkerContext, node: Node, parent: Node | null, key: string | number | symbol | null | undefined, index: number | null | undefined) => Promise<void>;
|
||||
import { WalkerBase } from "./walker.js";
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"proto.d.ts","sourceRoot":"","sources":["../../src/api/proto.ts"],"names":[],"mappings":"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"}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,9 @@
|
||||
import sha1 from './sha1.js';
|
||||
import v35, { DNS, URL } from './v35.js';
|
||||
export { DNS, URL } from './v35.js';
|
||||
function v5(value, namespace, buf, offset) {
|
||||
return v35(0x50, sha1, value, namespace, buf, offset);
|
||||
}
|
||||
v5.DNS = DNS;
|
||||
v5.URL = URL;
|
||||
export default v5;
|
||||
@@ -0,0 +1,4 @@
|
||||
declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"useThisType", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
export default _default;
|
||||
@@ -0,0 +1,18 @@
|
||||
import type { TSESTree } from '@typescript-eslint/utils';
|
||||
import type { InferMessageIdsTypeFromRule, InferOptionsTypeFromRule } from '../util';
|
||||
declare const baseRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingReturn" | "missingReturnValue" | "unexpectedReturnValue", [({
|
||||
treatUndefinedAsUnspecified?: boolean;
|
||||
} | undefined)?], unknown, {
|
||||
'ArrowFunctionExpression:exit'(node: TSESTree.ArrowFunctionExpression): void;
|
||||
'FunctionDeclaration:exit'(node: TSESTree.FunctionDeclaration): void;
|
||||
'FunctionExpression:exit'(node: TSESTree.FunctionExpression): void;
|
||||
ReturnStatement(node: TSESTree.ReturnStatement): void;
|
||||
}>;
|
||||
export type Options = InferOptionsTypeFromRule<typeof baseRule>;
|
||||
export type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
|
||||
declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingReturn" | "missingReturnValue" | "unexpectedReturnValue", [({
|
||||
treatUndefinedAsUnspecified?: boolean;
|
||||
} | undefined)?], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
export default _default;
|
||||
@@ -0,0 +1,38 @@
|
||||
/**
|
||||
* @fileoverview Rule to flag use of continue statement
|
||||
* @author Borislav Zhivkov
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../types').Rule.RuleModule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "suggestion",
|
||||
|
||||
docs: {
|
||||
description: "Disallow `continue` statements",
|
||||
recommended: false,
|
||||
frozen: true,
|
||||
url: "https://eslint.org/docs/latest/rules/no-continue",
|
||||
},
|
||||
|
||||
schema: [],
|
||||
|
||||
messages: {
|
||||
unexpected: "Unexpected use of continue statement.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
return {
|
||||
ContinueStatement(node) {
|
||||
context.report({ node, messageId: "unexpected" });
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,215 @@
|
||||
/*
|
||||
* Browser-compatible JavaScript MD5
|
||||
*
|
||||
* Modification of JavaScript MD5
|
||||
* https://github.com/blueimp/JavaScript-MD5
|
||||
*
|
||||
* Copyright 2011, Sebastian Tschan
|
||||
* https://blueimp.net
|
||||
*
|
||||
* Licensed under the MIT license:
|
||||
* https://opensource.org/licenses/MIT
|
||||
*
|
||||
* Based on
|
||||
* A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
|
||||
* Digest Algorithm, as defined in RFC 1321.
|
||||
* Version 2.2 Copyright (C) Paul Johnston 1999 - 2009
|
||||
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
|
||||
* Distributed under the BSD License
|
||||
* See http://pajhome.org.uk/crypt/md5 for more info.
|
||||
*/
|
||||
function md5(bytes) {
|
||||
if (typeof bytes === 'string') {
|
||||
var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
|
||||
|
||||
bytes = new Uint8Array(msg.length);
|
||||
|
||||
for (var i = 0; i < msg.length; ++i) {
|
||||
bytes[i] = msg.charCodeAt(i);
|
||||
}
|
||||
}
|
||||
|
||||
return md5ToHexEncodedArray(wordsToMd5(bytesToWords(bytes), bytes.length * 8));
|
||||
}
|
||||
/*
|
||||
* Convert an array of little-endian words to an array of bytes
|
||||
*/
|
||||
|
||||
|
||||
function md5ToHexEncodedArray(input) {
|
||||
var output = [];
|
||||
var length32 = input.length * 32;
|
||||
var hexTab = '0123456789abcdef';
|
||||
|
||||
for (var i = 0; i < length32; i += 8) {
|
||||
var x = input[i >> 5] >>> i % 32 & 0xff;
|
||||
var hex = parseInt(hexTab.charAt(x >>> 4 & 0x0f) + hexTab.charAt(x & 0x0f), 16);
|
||||
output.push(hex);
|
||||
}
|
||||
|
||||
return output;
|
||||
}
|
||||
/**
|
||||
* Calculate output length with padding and bit length
|
||||
*/
|
||||
|
||||
|
||||
function getOutputLength(inputLength8) {
|
||||
return (inputLength8 + 64 >>> 9 << 4) + 14 + 1;
|
||||
}
|
||||
/*
|
||||
* Calculate the MD5 of an array of little-endian words, and a bit length.
|
||||
*/
|
||||
|
||||
|
||||
function wordsToMd5(x, len) {
|
||||
/* append padding */
|
||||
x[len >> 5] |= 0x80 << len % 32;
|
||||
x[getOutputLength(len) - 1] = len;
|
||||
var a = 1732584193;
|
||||
var b = -271733879;
|
||||
var c = -1732584194;
|
||||
var d = 271733878;
|
||||
|
||||
for (var i = 0; i < x.length; i += 16) {
|
||||
var olda = a;
|
||||
var oldb = b;
|
||||
var oldc = c;
|
||||
var oldd = d;
|
||||
a = md5ff(a, b, c, d, x[i], 7, -680876936);
|
||||
d = md5ff(d, a, b, c, x[i + 1], 12, -389564586);
|
||||
c = md5ff(c, d, a, b, x[i + 2], 17, 606105819);
|
||||
b = md5ff(b, c, d, a, x[i + 3], 22, -1044525330);
|
||||
a = md5ff(a, b, c, d, x[i + 4], 7, -176418897);
|
||||
d = md5ff(d, a, b, c, x[i + 5], 12, 1200080426);
|
||||
c = md5ff(c, d, a, b, x[i + 6], 17, -1473231341);
|
||||
b = md5ff(b, c, d, a, x[i + 7], 22, -45705983);
|
||||
a = md5ff(a, b, c, d, x[i + 8], 7, 1770035416);
|
||||
d = md5ff(d, a, b, c, x[i + 9], 12, -1958414417);
|
||||
c = md5ff(c, d, a, b, x[i + 10], 17, -42063);
|
||||
b = md5ff(b, c, d, a, x[i + 11], 22, -1990404162);
|
||||
a = md5ff(a, b, c, d, x[i + 12], 7, 1804603682);
|
||||
d = md5ff(d, a, b, c, x[i + 13], 12, -40341101);
|
||||
c = md5ff(c, d, a, b, x[i + 14], 17, -1502002290);
|
||||
b = md5ff(b, c, d, a, x[i + 15], 22, 1236535329);
|
||||
a = md5gg(a, b, c, d, x[i + 1], 5, -165796510);
|
||||
d = md5gg(d, a, b, c, x[i + 6], 9, -1069501632);
|
||||
c = md5gg(c, d, a, b, x[i + 11], 14, 643717713);
|
||||
b = md5gg(b, c, d, a, x[i], 20, -373897302);
|
||||
a = md5gg(a, b, c, d, x[i + 5], 5, -701558691);
|
||||
d = md5gg(d, a, b, c, x[i + 10], 9, 38016083);
|
||||
c = md5gg(c, d, a, b, x[i + 15], 14, -660478335);
|
||||
b = md5gg(b, c, d, a, x[i + 4], 20, -405537848);
|
||||
a = md5gg(a, b, c, d, x[i + 9], 5, 568446438);
|
||||
d = md5gg(d, a, b, c, x[i + 14], 9, -1019803690);
|
||||
c = md5gg(c, d, a, b, x[i + 3], 14, -187363961);
|
||||
b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501);
|
||||
a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467);
|
||||
d = md5gg(d, a, b, c, x[i + 2], 9, -51403784);
|
||||
c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473);
|
||||
b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734);
|
||||
a = md5hh(a, b, c, d, x[i + 5], 4, -378558);
|
||||
d = md5hh(d, a, b, c, x[i + 8], 11, -2022574463);
|
||||
c = md5hh(c, d, a, b, x[i + 11], 16, 1839030562);
|
||||
b = md5hh(b, c, d, a, x[i + 14], 23, -35309556);
|
||||
a = md5hh(a, b, c, d, x[i + 1], 4, -1530992060);
|
||||
d = md5hh(d, a, b, c, x[i + 4], 11, 1272893353);
|
||||
c = md5hh(c, d, a, b, x[i + 7], 16, -155497632);
|
||||
b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640);
|
||||
a = md5hh(a, b, c, d, x[i + 13], 4, 681279174);
|
||||
d = md5hh(d, a, b, c, x[i], 11, -358537222);
|
||||
c = md5hh(c, d, a, b, x[i + 3], 16, -722521979);
|
||||
b = md5hh(b, c, d, a, x[i + 6], 23, 76029189);
|
||||
a = md5hh(a, b, c, d, x[i + 9], 4, -640364487);
|
||||
d = md5hh(d, a, b, c, x[i + 12], 11, -421815835);
|
||||
c = md5hh(c, d, a, b, x[i + 15], 16, 530742520);
|
||||
b = md5hh(b, c, d, a, x[i + 2], 23, -995338651);
|
||||
a = md5ii(a, b, c, d, x[i], 6, -198630844);
|
||||
d = md5ii(d, a, b, c, x[i + 7], 10, 1126891415);
|
||||
c = md5ii(c, d, a, b, x[i + 14], 15, -1416354905);
|
||||
b = md5ii(b, c, d, a, x[i + 5], 21, -57434055);
|
||||
a = md5ii(a, b, c, d, x[i + 12], 6, 1700485571);
|
||||
d = md5ii(d, a, b, c, x[i + 3], 10, -1894986606);
|
||||
c = md5ii(c, d, a, b, x[i + 10], 15, -1051523);
|
||||
b = md5ii(b, c, d, a, x[i + 1], 21, -2054922799);
|
||||
a = md5ii(a, b, c, d, x[i + 8], 6, 1873313359);
|
||||
d = md5ii(d, a, b, c, x[i + 15], 10, -30611744);
|
||||
c = md5ii(c, d, a, b, x[i + 6], 15, -1560198380);
|
||||
b = md5ii(b, c, d, a, x[i + 13], 21, 1309151649);
|
||||
a = md5ii(a, b, c, d, x[i + 4], 6, -145523070);
|
||||
d = md5ii(d, a, b, c, x[i + 11], 10, -1120210379);
|
||||
c = md5ii(c, d, a, b, x[i + 2], 15, 718787259);
|
||||
b = md5ii(b, c, d, a, x[i + 9], 21, -343485551);
|
||||
a = safeAdd(a, olda);
|
||||
b = safeAdd(b, oldb);
|
||||
c = safeAdd(c, oldc);
|
||||
d = safeAdd(d, oldd);
|
||||
}
|
||||
|
||||
return [a, b, c, d];
|
||||
}
|
||||
/*
|
||||
* Convert an array bytes to an array of little-endian words
|
||||
* Characters >255 have their high-byte silently ignored.
|
||||
*/
|
||||
|
||||
|
||||
function bytesToWords(input) {
|
||||
if (input.length === 0) {
|
||||
return [];
|
||||
}
|
||||
|
||||
var length8 = input.length * 8;
|
||||
var output = new Uint32Array(getOutputLength(length8));
|
||||
|
||||
for (var i = 0; i < length8; i += 8) {
|
||||
output[i >> 5] |= (input[i / 8] & 0xff) << i % 32;
|
||||
}
|
||||
|
||||
return output;
|
||||
}
|
||||
/*
|
||||
* Add integers, wrapping at 2^32. This uses 16-bit operations internally
|
||||
* to work around bugs in some JS interpreters.
|
||||
*/
|
||||
|
||||
|
||||
function safeAdd(x, y) {
|
||||
var lsw = (x & 0xffff) + (y & 0xffff);
|
||||
var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
|
||||
return msw << 16 | lsw & 0xffff;
|
||||
}
|
||||
/*
|
||||
* Bitwise rotate a 32-bit number to the left.
|
||||
*/
|
||||
|
||||
|
||||
function bitRotateLeft(num, cnt) {
|
||||
return num << cnt | num >>> 32 - cnt;
|
||||
}
|
||||
/*
|
||||
* These functions implement the four basic operations the algorithm uses.
|
||||
*/
|
||||
|
||||
|
||||
function md5cmn(q, a, b, x, s, t) {
|
||||
return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b);
|
||||
}
|
||||
|
||||
function md5ff(a, b, c, d, x, s, t) {
|
||||
return md5cmn(b & c | ~b & d, a, b, x, s, t);
|
||||
}
|
||||
|
||||
function md5gg(a, b, c, d, x, s, t) {
|
||||
return md5cmn(b & d | c & ~d, a, b, x, s, t);
|
||||
}
|
||||
|
||||
function md5hh(a, b, c, d, x, s, t) {
|
||||
return md5cmn(b ^ c ^ d, a, b, x, s, t);
|
||||
}
|
||||
|
||||
function md5ii(a, b, c, d, x, s, t) {
|
||||
return md5cmn(c ^ (b | ~d), a, b, x, s, t);
|
||||
}
|
||||
|
||||
export default md5;
|
||||
Reference in New Issue
Block a user