WIP: bootstrap and partial real Solana watcher implementation
This commit is contained in:
@@ -0,0 +1 @@
|
||||
export declare function file(): string
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,16 @@
|
||||
/**
|
||||
* @author Toru Nagashima <https://github.com/mysticatea>
|
||||
*/
|
||||
"use strict";
|
||||
|
||||
const isCombiningCharacter = require("./is-combining-character");
|
||||
const isEmojiModifier = require("./is-emoji-modifier");
|
||||
const isRegionalIndicatorSymbol = require("./is-regional-indicator-symbol");
|
||||
const isSurrogatePair = require("./is-surrogate-pair");
|
||||
|
||||
module.exports = {
|
||||
isCombiningCharacter,
|
||||
isEmojiModifier,
|
||||
isRegionalIndicatorSymbol,
|
||||
isSurrogatePair,
|
||||
};
|
||||
@@ -0,0 +1,37 @@
|
||||
{
|
||||
"name": "@pinojs/redact",
|
||||
"version": "0.4.0",
|
||||
"description": "Redact JS objects",
|
||||
"main": "index.js",
|
||||
"types": "index.d.ts",
|
||||
"scripts": {
|
||||
"test": "node --test && npm run test:types",
|
||||
"test:integration": "node --test test/integration.test.js",
|
||||
"test:types": "tsd",
|
||||
"test:all": "node --test test/*.test.js",
|
||||
"lint": "eslint .",
|
||||
"lint:fix": "eslint . --fix",
|
||||
"bench": "node benchmarks/basic.js"
|
||||
},
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git+https://github.com/pinojs/redact.git"
|
||||
},
|
||||
"keywords": [
|
||||
"redact"
|
||||
],
|
||||
"author": "Matteo Collina <hello@matteocollina.com>",
|
||||
"license": "MIT",
|
||||
"bugs": {
|
||||
"url": "https://github.com/pinojs/redact/issues"
|
||||
},
|
||||
"homepage": "https://github.com/pinojs/redact#readme",
|
||||
"devDependencies": {
|
||||
"eslint": "^9.36.0",
|
||||
"fast-redact": "^3.5.0",
|
||||
"mitata": "^1.0.34",
|
||||
"neostandard": "^0.12.2",
|
||||
"tsd": "^0.33.0",
|
||||
"typescript": "^5.9.2"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"i32.d.ts","sourceRoot":"","sources":["../../src/i32.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvG,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAO5F,CAAC;AAEP;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,iBAAsB,KAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAMnF,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,WAAW,GAAI,SAAQ,iBAAsB,KAAG,cAAc,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,CAAC,CACxC,CAAC"}
|
||||
@@ -0,0 +1,119 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.Reference = exports.ReferenceTypeFlag = exports.ReferenceFlag = void 0;
|
||||
const ID_1 = require("../ID");
|
||||
var ReferenceFlag;
|
||||
(function (ReferenceFlag) {
|
||||
ReferenceFlag[ReferenceFlag["Read"] = 1] = "Read";
|
||||
ReferenceFlag[ReferenceFlag["Write"] = 2] = "Write";
|
||||
ReferenceFlag[ReferenceFlag["ReadWrite"] = 3] = "ReadWrite";
|
||||
})(ReferenceFlag || (exports.ReferenceFlag = ReferenceFlag = {}));
|
||||
const generator = (0, ID_1.createIdGenerator)();
|
||||
var ReferenceTypeFlag;
|
||||
(function (ReferenceTypeFlag) {
|
||||
ReferenceTypeFlag[ReferenceTypeFlag["Value"] = 1] = "Value";
|
||||
ReferenceTypeFlag[ReferenceTypeFlag["Type"] = 2] = "Type";
|
||||
})(ReferenceTypeFlag || (exports.ReferenceTypeFlag = ReferenceTypeFlag = {}));
|
||||
/**
|
||||
* A Reference represents a single occurrence of an identifier in code.
|
||||
*/
|
||||
class Reference {
|
||||
/**
|
||||
* A unique ID for this instance - primarily used to help debugging and testing
|
||||
*/
|
||||
$id = generator();
|
||||
/**
|
||||
* The read-write mode of the reference.
|
||||
*/
|
||||
#flag;
|
||||
/**
|
||||
* Reference to the enclosing Scope.
|
||||
* @public
|
||||
*/
|
||||
from;
|
||||
/**
|
||||
* Identifier syntax node.
|
||||
* @public
|
||||
*/
|
||||
identifier;
|
||||
/**
|
||||
* `true` if this writing reference is a variable initializer or a default value.
|
||||
* @public
|
||||
*/
|
||||
init;
|
||||
maybeImplicitGlobal;
|
||||
/**
|
||||
* The {@link Variable} object that this reference refers to. If such variable was not defined, this is `null`.
|
||||
* @public
|
||||
*/
|
||||
resolved;
|
||||
/**
|
||||
* If reference is writeable, this is the node being written to it.
|
||||
* @public
|
||||
*/
|
||||
writeExpr;
|
||||
/**
|
||||
* In some cases, a reference may be a type, value or both a type and value reference.
|
||||
*/
|
||||
#referenceType;
|
||||
constructor(identifier, scope, flag, writeExpr, maybeImplicitGlobal, init, referenceType = ReferenceTypeFlag.Value) {
|
||||
this.identifier = identifier;
|
||||
this.from = scope;
|
||||
this.resolved = null;
|
||||
this.#flag = flag;
|
||||
if (this.isWrite()) {
|
||||
this.writeExpr = writeExpr;
|
||||
this.init = init;
|
||||
}
|
||||
this.maybeImplicitGlobal = maybeImplicitGlobal;
|
||||
this.#referenceType = referenceType;
|
||||
}
|
||||
/**
|
||||
* True if this reference can reference types
|
||||
*/
|
||||
get isTypeReference() {
|
||||
return (this.#referenceType & ReferenceTypeFlag.Type) !== 0;
|
||||
}
|
||||
/**
|
||||
* True if this reference can reference values
|
||||
*/
|
||||
get isValueReference() {
|
||||
return (this.#referenceType & ReferenceTypeFlag.Value) !== 0;
|
||||
}
|
||||
/**
|
||||
* Whether the reference is writeable.
|
||||
* @public
|
||||
*/
|
||||
isWrite() {
|
||||
return !!(this.#flag & ReferenceFlag.Write);
|
||||
}
|
||||
/**
|
||||
* Whether the reference is readable.
|
||||
* @public
|
||||
*/
|
||||
isRead() {
|
||||
return !!(this.#flag & ReferenceFlag.Read);
|
||||
}
|
||||
/**
|
||||
* Whether the reference is read-only.
|
||||
* @public
|
||||
*/
|
||||
isReadOnly() {
|
||||
return this.#flag === ReferenceFlag.Read;
|
||||
}
|
||||
/**
|
||||
* Whether the reference is write-only.
|
||||
* @public
|
||||
*/
|
||||
isWriteOnly() {
|
||||
return this.#flag === ReferenceFlag.Write;
|
||||
}
|
||||
/**
|
||||
* Whether the reference is read-write.
|
||||
* @public
|
||||
*/
|
||||
isReadWrite() {
|
||||
return this.#flag === ReferenceFlag.ReadWrite;
|
||||
}
|
||||
}
|
||||
exports.Reference = Reference;
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"_shortw_utils.js","sourceRoot":"","sources":["src/_shortw_utils.ts"],"names":[],"mappings":";;AASA,0BAEC;AAMD,kCAGC;AApBD;;;GAGG;AACH,sEAAsE;AACtE,8DAAsF;AAGtF,4CAA4C;AAC5C,SAAgB,OAAO,CAAC,IAAW;IACjC,OAAO,EAAE,IAAI,EAAE,CAAC;AAClB,CAAC;AAKD,gEAAgE;AAChE,SAAgB,WAAW,CAAC,QAAkB,EAAE,OAAc;IAC5D,MAAM,MAAM,GAAG,CAAC,IAAW,EAAW,EAAE,CAAC,IAAA,4BAAW,EAAC,EAAE,GAAG,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;IAClF,OAAO,EAAE,GAAG,MAAM,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;AACxC,CAAC"}
|
||||
@@ -0,0 +1,241 @@
|
||||
/**
|
||||
* @fileoverview Rule that warns when identifier names that are
|
||||
* specified in the configuration are used.
|
||||
* @author Keith Cirkel (http://keithcirkel.co.uk)
|
||||
* @deprecated in ESLint v7.5.0
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Checks whether the given node represents assignment target in a normal assignment or destructuring.
|
||||
* @param {ASTNode} node The node to check.
|
||||
* @returns {boolean} `true` if the node is assignment target.
|
||||
*/
|
||||
function isAssignmentTarget(node) {
|
||||
const parent = node.parent;
|
||||
|
||||
return (
|
||||
// normal assignment
|
||||
(parent.type === "AssignmentExpression" && parent.left === node) ||
|
||||
// destructuring
|
||||
parent.type === "ArrayPattern" ||
|
||||
parent.type === "RestElement" ||
|
||||
(parent.type === "Property" &&
|
||||
parent.value === node &&
|
||||
parent.parent.type === "ObjectPattern") ||
|
||||
(parent.type === "AssignmentPattern" && parent.left === node)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks whether the given node represents an imported name that is renamed in the same import/export specifier.
|
||||
*
|
||||
* Examples:
|
||||
* import { a as b } from 'mod'; // node `a` is renamed import
|
||||
* export { a as b } from 'mod'; // node `a` is renamed import
|
||||
* @param {ASTNode} node `Identifier` node to check.
|
||||
* @returns {boolean} `true` if the node is a renamed import.
|
||||
*/
|
||||
function isRenamedImport(node) {
|
||||
const parent = node.parent;
|
||||
|
||||
return (
|
||||
(parent.type === "ImportSpecifier" &&
|
||||
parent.imported !== parent.local &&
|
||||
parent.imported === node) ||
|
||||
(parent.type === "ExportSpecifier" &&
|
||||
parent.parent.source && // re-export
|
||||
parent.local !== parent.exported &&
|
||||
parent.local === node)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks whether the given node is a renamed identifier node in an ObjectPattern destructuring.
|
||||
*
|
||||
* Examples:
|
||||
* const { a : b } = foo; // node `a` is renamed node.
|
||||
* @param {ASTNode} node `Identifier` node to check.
|
||||
* @returns {boolean} `true` if the node is a renamed node in an ObjectPattern destructuring.
|
||||
*/
|
||||
function isRenamedInDestructuring(node) {
|
||||
const parent = node.parent;
|
||||
|
||||
return (
|
||||
!parent.computed &&
|
||||
parent.type === "Property" &&
|
||||
parent.parent.type === "ObjectPattern" &&
|
||||
parent.value !== node &&
|
||||
parent.key === node
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks whether the given node represents shorthand definition of a property in an object literal.
|
||||
* @param {ASTNode} node `Identifier` node to check.
|
||||
* @returns {boolean} `true` if the node is a shorthand property definition.
|
||||
*/
|
||||
function isShorthandPropertyDefinition(node) {
|
||||
const parent = node.parent;
|
||||
|
||||
return (
|
||||
parent.type === "Property" &&
|
||||
parent.parent.type === "ObjectExpression" &&
|
||||
parent.shorthand
|
||||
);
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../types').Rule.RuleModule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
deprecated: {
|
||||
message: "The rule was renamed.",
|
||||
url: "https://eslint.org/blog/2020/07/eslint-v7.5.0-released/#deprecating-id-blacklist",
|
||||
deprecatedSince: "7.5.0",
|
||||
availableUntil: "11.0.0",
|
||||
replacedBy: [
|
||||
{
|
||||
rule: {
|
||||
name: "id-denylist",
|
||||
url: "https://eslint.org/docs/rules/id-denylist",
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
|
||||
type: "suggestion",
|
||||
|
||||
docs: {
|
||||
description: "Disallow specified identifiers",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/id-blacklist",
|
||||
},
|
||||
|
||||
schema: {
|
||||
type: "array",
|
||||
items: {
|
||||
type: "string",
|
||||
},
|
||||
uniqueItems: true,
|
||||
},
|
||||
messages: {
|
||||
restricted: "Identifier '{{name}}' is restricted.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const denyList = new Set(context.options);
|
||||
const reportedNodes = new Set();
|
||||
const sourceCode = context.sourceCode;
|
||||
|
||||
let globalScope;
|
||||
|
||||
/**
|
||||
* Checks whether the given name is restricted.
|
||||
* @param {string} name The name to check.
|
||||
* @returns {boolean} `true` if the name is restricted.
|
||||
* @private
|
||||
*/
|
||||
function isRestricted(name) {
|
||||
return denyList.has(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks whether the given node represents a reference to a global variable that is not declared in the source code.
|
||||
* These identifiers will be allowed, as it is assumed that user has no control over the names of external global variables.
|
||||
* @param {ASTNode} node `Identifier` node to check.
|
||||
* @returns {boolean} `true` if the node is a reference to a global variable.
|
||||
*/
|
||||
function isReferenceToGlobalVariable(node) {
|
||||
const variable = globalScope.set.get(node.name);
|
||||
|
||||
return (
|
||||
variable &&
|
||||
variable.defs.length === 0 &&
|
||||
variable.references.some(ref => ref.identifier === node)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines whether the given node should be checked.
|
||||
* @param {ASTNode} node `Identifier` node.
|
||||
* @returns {boolean} `true` if the node should be checked.
|
||||
*/
|
||||
function shouldCheck(node) {
|
||||
const parent = node.parent;
|
||||
|
||||
/*
|
||||
* Member access has special rules for checking property names.
|
||||
* Read access to a property with a restricted name is allowed, because it can be on an object that user has no control over.
|
||||
* Write access isn't allowed, because it potentially creates a new property with a restricted name.
|
||||
*/
|
||||
if (
|
||||
parent.type === "MemberExpression" &&
|
||||
parent.property === node &&
|
||||
!parent.computed
|
||||
) {
|
||||
return isAssignmentTarget(parent);
|
||||
}
|
||||
|
||||
return (
|
||||
parent.type !== "CallExpression" &&
|
||||
parent.type !== "NewExpression" &&
|
||||
!isRenamedImport(node) &&
|
||||
!isRenamedInDestructuring(node) &&
|
||||
!(
|
||||
isReferenceToGlobalVariable(node) &&
|
||||
!isShorthandPropertyDefinition(node)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Reports an AST node as a rule violation.
|
||||
* @param {ASTNode} node The node to report.
|
||||
* @returns {void}
|
||||
* @private
|
||||
*/
|
||||
function report(node) {
|
||||
/*
|
||||
* We used the range instead of the node because it's possible
|
||||
* for the same identifier to be represented by two different
|
||||
* nodes, with the most clear example being shorthand properties:
|
||||
* { foo }
|
||||
* In this case, "foo" is represented by one node for the name
|
||||
* and one for the value. The only way to know they are the same
|
||||
* is to look at the range.
|
||||
*/
|
||||
if (!reportedNodes.has(node.range.toString())) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "restricted",
|
||||
data: {
|
||||
name: node.name,
|
||||
},
|
||||
});
|
||||
reportedNodes.add(node.range.toString());
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
Program(node) {
|
||||
globalScope = sourceCode.getScope(node);
|
||||
},
|
||||
|
||||
Identifier(node) {
|
||||
if (isRestricted(node.name) && shouldCheck(node)) {
|
||||
report(node);
|
||||
}
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,243 @@
|
||||
// @ts-ignore TS6133
|
||||
import { expect, test } from "vitest";
|
||||
|
||||
import * as z from "zod/v3";
|
||||
import { ZodNullable, ZodOptional } from "zod/v3";
|
||||
import { util } from "../helpers/util.js";
|
||||
|
||||
const nested = z.object({
|
||||
name: z.string(),
|
||||
age: z.number(),
|
||||
outer: z.object({
|
||||
inner: z.string(),
|
||||
}),
|
||||
array: z.array(z.object({ asdf: z.string() })),
|
||||
});
|
||||
|
||||
test("shallow inference", () => {
|
||||
const shallow = nested.partial();
|
||||
type shallow = z.infer<typeof shallow>;
|
||||
type correct = {
|
||||
name?: string | undefined;
|
||||
age?: number | undefined;
|
||||
outer?: { inner: string } | undefined;
|
||||
array?: { asdf: string }[] | undefined;
|
||||
};
|
||||
util.assertEqual<shallow, correct>(true);
|
||||
});
|
||||
|
||||
test("shallow partial parse", () => {
|
||||
const shallow = nested.partial();
|
||||
shallow.parse({});
|
||||
shallow.parse({
|
||||
name: "asdf",
|
||||
age: 23143,
|
||||
});
|
||||
});
|
||||
|
||||
test("deep partial inference", () => {
|
||||
const deep = nested.deepPartial();
|
||||
const asdf = deep.shape.array.unwrap().element.shape.asdf.unwrap();
|
||||
asdf.parse("asdf");
|
||||
type deep = z.infer<typeof deep>;
|
||||
type correct = {
|
||||
array?: { asdf?: string | undefined }[] | undefined;
|
||||
name?: string | undefined;
|
||||
age?: number | undefined;
|
||||
outer?: { inner?: string | undefined } | undefined;
|
||||
};
|
||||
|
||||
util.assertEqual<deep, correct>(true);
|
||||
});
|
||||
|
||||
test("deep partial parse", () => {
|
||||
const deep = nested.deepPartial();
|
||||
|
||||
expect(deep.shape.name instanceof z.ZodOptional).toBe(true);
|
||||
expect(deep.shape.outer instanceof z.ZodOptional).toBe(true);
|
||||
expect(deep.shape.outer._def.innerType instanceof z.ZodObject).toBe(true);
|
||||
expect(deep.shape.outer._def.innerType.shape.inner instanceof z.ZodOptional).toBe(true);
|
||||
expect(deep.shape.outer._def.innerType.shape.inner._def.innerType instanceof z.ZodString).toBe(true);
|
||||
});
|
||||
|
||||
test("deep partial runtime tests", () => {
|
||||
const deep = nested.deepPartial();
|
||||
deep.parse({});
|
||||
deep.parse({
|
||||
outer: {},
|
||||
});
|
||||
deep.parse({
|
||||
name: "asdf",
|
||||
age: 23143,
|
||||
outer: {
|
||||
inner: "adsf",
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
test("deep partial optional/nullable", () => {
|
||||
const schema = z
|
||||
.object({
|
||||
name: z.string().optional(),
|
||||
age: z.number().nullable(),
|
||||
})
|
||||
.deepPartial();
|
||||
|
||||
expect(schema.shape.name.unwrap()).toBeInstanceOf(ZodOptional);
|
||||
expect(schema.shape.age.unwrap()).toBeInstanceOf(ZodNullable);
|
||||
});
|
||||
|
||||
test("deep partial tuple", () => {
|
||||
const schema = z
|
||||
.object({
|
||||
tuple: z.tuple([
|
||||
z.object({
|
||||
name: z.string().optional(),
|
||||
age: z.number().nullable(),
|
||||
}),
|
||||
]),
|
||||
})
|
||||
.deepPartial();
|
||||
|
||||
expect(schema.shape.tuple.unwrap().items[0].shape.name).toBeInstanceOf(ZodOptional);
|
||||
});
|
||||
|
||||
test("deep partial inference", () => {
|
||||
const mySchema = z.object({
|
||||
name: z.string(),
|
||||
array: z.array(z.object({ asdf: z.string() })),
|
||||
tuple: z.tuple([z.object({ value: z.string() })]),
|
||||
});
|
||||
|
||||
const partialed = mySchema.deepPartial();
|
||||
type partialed = z.infer<typeof partialed>;
|
||||
type expected = {
|
||||
name?: string | undefined;
|
||||
array?:
|
||||
| {
|
||||
asdf?: string | undefined;
|
||||
}[]
|
||||
| undefined;
|
||||
tuple?: [{ value?: string | undefined }] | undefined;
|
||||
};
|
||||
util.assertEqual<expected, partialed>(true);
|
||||
});
|
||||
|
||||
test("required", () => {
|
||||
const object = z.object({
|
||||
name: z.string(),
|
||||
age: z.number().optional(),
|
||||
field: z.string().optional().default("asdf"),
|
||||
nullableField: z.number().nullable(),
|
||||
nullishField: z.string().nullish(),
|
||||
});
|
||||
|
||||
const requiredObject = object.required();
|
||||
expect(requiredObject.shape.name).toBeInstanceOf(z.ZodString);
|
||||
expect(requiredObject.shape.age).toBeInstanceOf(z.ZodNumber);
|
||||
expect(requiredObject.shape.field).toBeInstanceOf(z.ZodDefault);
|
||||
expect(requiredObject.shape.nullableField).toBeInstanceOf(z.ZodNullable);
|
||||
expect(requiredObject.shape.nullishField).toBeInstanceOf(z.ZodNullable);
|
||||
});
|
||||
|
||||
test("required inference", () => {
|
||||
const object = z.object({
|
||||
name: z.string(),
|
||||
age: z.number().optional(),
|
||||
field: z.string().optional().default("asdf"),
|
||||
nullableField: z.number().nullable(),
|
||||
nullishField: z.string().nullish(),
|
||||
});
|
||||
|
||||
const requiredObject = object.required();
|
||||
|
||||
type required = z.infer<typeof requiredObject>;
|
||||
type expected = {
|
||||
name: string;
|
||||
age: number;
|
||||
field: string;
|
||||
nullableField: number | null;
|
||||
nullishField: string | null;
|
||||
};
|
||||
util.assertEqual<expected, required>(true);
|
||||
});
|
||||
|
||||
test("required with mask", () => {
|
||||
const object = z.object({
|
||||
name: z.string(),
|
||||
age: z.number().optional(),
|
||||
field: z.string().optional().default("asdf"),
|
||||
country: z.string().optional(),
|
||||
});
|
||||
|
||||
const requiredObject = object.required({ age: true });
|
||||
expect(requiredObject.shape.name).toBeInstanceOf(z.ZodString);
|
||||
expect(requiredObject.shape.age).toBeInstanceOf(z.ZodNumber);
|
||||
expect(requiredObject.shape.field).toBeInstanceOf(z.ZodDefault);
|
||||
expect(requiredObject.shape.country).toBeInstanceOf(z.ZodOptional);
|
||||
});
|
||||
|
||||
test("required with mask -- ignore falsy values", () => {
|
||||
const object = z.object({
|
||||
name: z.string(),
|
||||
age: z.number().optional(),
|
||||
field: z.string().optional().default("asdf"),
|
||||
country: z.string().optional(),
|
||||
});
|
||||
|
||||
// @ts-expect-error
|
||||
const requiredObject = object.required({ age: true, country: false });
|
||||
expect(requiredObject.shape.name).toBeInstanceOf(z.ZodString);
|
||||
expect(requiredObject.shape.age).toBeInstanceOf(z.ZodNumber);
|
||||
expect(requiredObject.shape.field).toBeInstanceOf(z.ZodDefault);
|
||||
expect(requiredObject.shape.country).toBeInstanceOf(z.ZodOptional);
|
||||
});
|
||||
|
||||
test("partial with mask", async () => {
|
||||
const object = z.object({
|
||||
name: z.string(),
|
||||
age: z.number().optional(),
|
||||
field: z.string().optional().default("asdf"),
|
||||
country: z.string(),
|
||||
});
|
||||
|
||||
const masked = object.partial({ age: true, field: true, name: true }).strict();
|
||||
|
||||
expect(masked.shape.name).toBeInstanceOf(z.ZodOptional);
|
||||
expect(masked.shape.age).toBeInstanceOf(z.ZodOptional);
|
||||
expect(masked.shape.field).toBeInstanceOf(z.ZodOptional);
|
||||
expect(masked.shape.country).toBeInstanceOf(z.ZodString);
|
||||
|
||||
masked.parse({ country: "US" });
|
||||
await masked.parseAsync({ country: "US" });
|
||||
});
|
||||
|
||||
test("partial with mask -- ignore falsy values", async () => {
|
||||
const object = z.object({
|
||||
name: z.string(),
|
||||
age: z.number().optional(),
|
||||
field: z.string().optional().default("asdf"),
|
||||
country: z.string(),
|
||||
});
|
||||
|
||||
// @ts-expect-error
|
||||
const masked = object.partial({ name: true, country: false }).strict();
|
||||
|
||||
expect(masked.shape.name).toBeInstanceOf(z.ZodOptional);
|
||||
expect(masked.shape.age).toBeInstanceOf(z.ZodOptional);
|
||||
expect(masked.shape.field).toBeInstanceOf(z.ZodDefault);
|
||||
expect(masked.shape.country).toBeInstanceOf(z.ZodString);
|
||||
|
||||
masked.parse({ country: "US" });
|
||||
await masked.parseAsync({ country: "US" });
|
||||
});
|
||||
|
||||
test("deeppartial array", () => {
|
||||
const schema = z.object({ array: z.string().array().min(42) }).deepPartial();
|
||||
|
||||
// works as expected
|
||||
schema.parse({});
|
||||
|
||||
// should be false, but is true
|
||||
expect(schema.safeParse({ array: [] }).success).toBe(false);
|
||||
});
|
||||
@@ -0,0 +1,133 @@
|
||||
"use strict";
|
||||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
var desc = Object.getOwnPropertyDescriptor(m, k);
|
||||
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
||||
desc = { enumerable: true, get: function() { return m[k]; } };
|
||||
}
|
||||
Object.defineProperty(o, k2, desc);
|
||||
}) : (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
o[k2] = m[k];
|
||||
}));
|
||||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
||||
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||||
}) : function(o, v) {
|
||||
o["default"] = v;
|
||||
});
|
||||
var __importStar = (this && this.__importStar) || function (mod) {
|
||||
if (mod && mod.__esModule) return mod;
|
||||
var result = {};
|
||||
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
||||
__setModuleDefault(result, mod);
|
||||
return result;
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.default = default_1;
|
||||
const util = __importStar(require("../core/util.cjs"));
|
||||
const error = () => {
|
||||
const Sizable = {
|
||||
string: { unit: "karakter", verb: "memiliki" },
|
||||
file: { unit: "byte", verb: "memiliki" },
|
||||
array: { unit: "item", verb: "memiliki" },
|
||||
set: { unit: "item", verb: "memiliki" },
|
||||
};
|
||||
function getSizing(origin) {
|
||||
return Sizable[origin] ?? null;
|
||||
}
|
||||
const FormatDictionary = {
|
||||
regex: "input",
|
||||
email: "alamat email",
|
||||
url: "URL",
|
||||
emoji: "emoji",
|
||||
uuid: "UUID",
|
||||
uuidv4: "UUIDv4",
|
||||
uuidv6: "UUIDv6",
|
||||
nanoid: "nanoid",
|
||||
guid: "GUID",
|
||||
cuid: "cuid",
|
||||
cuid2: "cuid2",
|
||||
ulid: "ULID",
|
||||
xid: "XID",
|
||||
ksuid: "KSUID",
|
||||
datetime: "tanggal dan waktu format ISO",
|
||||
date: "tanggal format ISO",
|
||||
time: "jam format ISO",
|
||||
duration: "durasi format ISO",
|
||||
ipv4: "alamat IPv4",
|
||||
ipv6: "alamat IPv6",
|
||||
cidrv4: "rentang alamat IPv4",
|
||||
cidrv6: "rentang alamat IPv6",
|
||||
base64: "string dengan enkode base64",
|
||||
base64url: "string dengan enkode base64url",
|
||||
json_string: "string JSON",
|
||||
e164: "angka E.164",
|
||||
jwt: "JWT",
|
||||
template_literal: "input",
|
||||
};
|
||||
const TypeDictionary = {
|
||||
nan: "NaN",
|
||||
};
|
||||
return (issue) => {
|
||||
switch (issue.code) {
|
||||
case "invalid_type": {
|
||||
const expected = TypeDictionary[issue.expected] ?? issue.expected;
|
||||
const receivedType = util.parsedType(issue.input);
|
||||
const received = TypeDictionary[receivedType] ?? receivedType;
|
||||
if (/^[A-Z]/.test(issue.expected)) {
|
||||
return `Input tidak valid: diharapkan instanceof ${issue.expected}, diterima ${received}`;
|
||||
}
|
||||
return `Input tidak valid: diharapkan ${expected}, diterima ${received}`;
|
||||
}
|
||||
case "invalid_value":
|
||||
if (issue.values.length === 1)
|
||||
return `Input tidak valid: diharapkan ${util.stringifyPrimitive(issue.values[0])}`;
|
||||
return `Pilihan tidak valid: diharapkan salah satu dari ${util.joinValues(issue.values, "|")}`;
|
||||
case "too_big": {
|
||||
const adj = issue.inclusive ? "<=" : "<";
|
||||
const sizing = getSizing(issue.origin);
|
||||
if (sizing)
|
||||
return `Terlalu besar: diharapkan ${issue.origin ?? "value"} memiliki ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elemen"}`;
|
||||
return `Terlalu besar: diharapkan ${issue.origin ?? "value"} menjadi ${adj}${issue.maximum.toString()}`;
|
||||
}
|
||||
case "too_small": {
|
||||
const adj = issue.inclusive ? ">=" : ">";
|
||||
const sizing = getSizing(issue.origin);
|
||||
if (sizing) {
|
||||
return `Terlalu kecil: diharapkan ${issue.origin} memiliki ${adj}${issue.minimum.toString()} ${sizing.unit}`;
|
||||
}
|
||||
return `Terlalu kecil: diharapkan ${issue.origin} menjadi ${adj}${issue.minimum.toString()}`;
|
||||
}
|
||||
case "invalid_format": {
|
||||
const _issue = issue;
|
||||
if (_issue.format === "starts_with")
|
||||
return `String tidak valid: harus dimulai dengan "${_issue.prefix}"`;
|
||||
if (_issue.format === "ends_with")
|
||||
return `String tidak valid: harus berakhir dengan "${_issue.suffix}"`;
|
||||
if (_issue.format === "includes")
|
||||
return `String tidak valid: harus menyertakan "${_issue.includes}"`;
|
||||
if (_issue.format === "regex")
|
||||
return `String tidak valid: harus sesuai pola ${_issue.pattern}`;
|
||||
return `${FormatDictionary[_issue.format] ?? issue.format} tidak valid`;
|
||||
}
|
||||
case "not_multiple_of":
|
||||
return `Angka tidak valid: harus kelipatan dari ${issue.divisor}`;
|
||||
case "unrecognized_keys":
|
||||
return `Kunci tidak dikenali ${issue.keys.length > 1 ? "s" : ""}: ${util.joinValues(issue.keys, ", ")}`;
|
||||
case "invalid_key":
|
||||
return `Kunci tidak valid di ${issue.origin}`;
|
||||
case "invalid_union":
|
||||
return "Input tidak valid";
|
||||
case "invalid_element":
|
||||
return `Nilai tidak valid di ${issue.origin}`;
|
||||
default:
|
||||
return `Input tidak valid`;
|
||||
}
|
||||
};
|
||||
};
|
||||
function default_1() {
|
||||
return {
|
||||
localeError: error(),
|
||||
};
|
||||
}
|
||||
module.exports = exports.default;
|
||||
@@ -0,0 +1,28 @@
|
||||
"use strict";
|
||||
|
||||
var REACT_ELEMENT_TYPE;
|
||||
function _jsx(type, props, key, children) {
|
||||
if (!REACT_ELEMENT_TYPE) {
|
||||
REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol.for && Symbol.for("react.element") || 0xeac7;
|
||||
}
|
||||
|
||||
var defaultProps = type && type.defaultProps;
|
||||
var childrenLength = arguments.length - 3;
|
||||
|
||||
if (!props && childrenLength !== 0) props = { children: void 0 };
|
||||
if (props && defaultProps) {
|
||||
for (var propName in defaultProps) {
|
||||
if (props[propName] === void 0) props[propName] = defaultProps[propName];
|
||||
else if (!props) props = defaultProps || {};
|
||||
}
|
||||
}
|
||||
if (childrenLength === 1) props.children = children;
|
||||
else if (childrenLength > 1) {
|
||||
var childArray = new Array(childrenLength);
|
||||
for (var i = 0; i < childrenLength; i++) childArray[i] = arguments[i + 3];
|
||||
props.children = childArray;
|
||||
}
|
||||
|
||||
return { $$typeof: REACT_ELEMENT_TYPE, type: type, key: key === undefined ? null : "" + key, ref: null, props: props, _owner: null };
|
||||
}
|
||||
exports._ = _jsx;
|
||||
@@ -0,0 +1,3 @@
|
||||
import cf from '../dist/index.js'
|
||||
|
||||
export const CloudflareSocket = cf.CloudflareSocket
|
||||
@@ -0,0 +1,238 @@
|
||||
# Optionator
|
||||
<a name="optionator" />
|
||||
|
||||
Optionator is a JavaScript/Node.js option parsing and help generation library used by [eslint](http://eslint.org), [Grasp](http://graspjs.com), [LiveScript](http://livescript.net), [esmangle](https://github.com/estools/esmangle), [escodegen](https://github.com/estools/escodegen), and [many more](https://www.npmjs.com/browse/depended/optionator).
|
||||
|
||||
For an online demo, check out the [Grasp online demo](http://www.graspjs.com/#demo).
|
||||
|
||||
[About](#about) · [Usage](#usage) · [Settings Format](#settings-format) · [Argument Format](#argument-format)
|
||||
|
||||
## Why?
|
||||
The problem with other option parsers, such as `yargs` or `minimist`, is they just accept all input, valid or not.
|
||||
With Optionator, if you mistype an option, it will give you an error (with a suggestion for what you meant).
|
||||
If you give the wrong type of argument for an option, it will give you an error rather than supplying the wrong input to your application.
|
||||
|
||||
$ cmd --halp
|
||||
Invalid option '--halp' - perhaps you meant '--help'?
|
||||
|
||||
$ cmd --count str
|
||||
Invalid value for option 'count' - expected type Int, received value: str.
|
||||
|
||||
Other helpful features include reformatting the help text based on the size of the console, so that it fits even if the console is narrow, and accepting not just an array (eg. process.argv), but a string or object as well, making things like testing much easier.
|
||||
|
||||
## About
|
||||
Optionator uses [type-check](https://github.com/gkz/type-check) and [levn](https://github.com/gkz/levn) behind the scenes to cast and verify input according the specified types.
|
||||
|
||||
MIT license. Version 0.9.4
|
||||
|
||||
npm install optionator
|
||||
|
||||
For updates on Optionator, [follow me on twitter](https://twitter.com/gkzahariev).
|
||||
|
||||
Optionator is a Node.js module, but can be used in the browser as well if packed with webpack/browserify.
|
||||
|
||||
## Usage
|
||||
`require('optionator');` returns a function. It has one property, `VERSION`, the current version of the library as a string. This function is called with an object specifying your options and other information, see the [settings format section](#settings-format). This in turn returns an object with three properties, `parse`, `parseArgv`, `generateHelp`, and `generateHelpForOption`, which are all functions.
|
||||
|
||||
```js
|
||||
var optionator = require('optionator')({
|
||||
prepend: 'Usage: cmd [options]',
|
||||
append: 'Version 1.0.0',
|
||||
options: [{
|
||||
option: 'help',
|
||||
alias: 'h',
|
||||
type: 'Boolean',
|
||||
description: 'displays help'
|
||||
}, {
|
||||
option: 'count',
|
||||
alias: 'c',
|
||||
type: 'Int',
|
||||
description: 'number of things',
|
||||
example: 'cmd --count 2'
|
||||
}]
|
||||
});
|
||||
|
||||
var options = optionator.parseArgv(process.argv);
|
||||
if (options.help) {
|
||||
console.log(optionator.generateHelp());
|
||||
}
|
||||
...
|
||||
```
|
||||
|
||||
### parse(input, parseOptions)
|
||||
`parse` processes the `input` according to your settings, and returns an object with the results.
|
||||
|
||||
##### arguments
|
||||
* input - `[String] | Object | String` - the input you wish to parse
|
||||
* parseOptions - `{slice: Int}` - all options optional
|
||||
- `slice` specifies how much to slice away from the beginning if the input is an array or string - by default `0` for string, `2` for array (works with `process.argv`)
|
||||
|
||||
##### returns
|
||||
`Object` - the parsed options, each key is a camelCase version of the option name (specified in dash-case), and each value is the processed value for that option. Positional values are in an array under the `_` key.
|
||||
|
||||
##### example
|
||||
```js
|
||||
parse(['node', 't.js', '--count', '2', 'positional']); // {count: 2, _: ['positional']}
|
||||
parse('--count 2 positional'); // {count: 2, _: ['positional']}
|
||||
parse({count: 2, _:['positional']}); // {count: 2, _: ['positional']}
|
||||
```
|
||||
|
||||
### parseArgv(input)
|
||||
`parseArgv` works exactly like `parse`, but only for array input and it slices off the first two elements.
|
||||
|
||||
##### arguments
|
||||
* input - `[String]` - the input you wish to parse
|
||||
|
||||
##### returns
|
||||
See "returns" section in "parse"
|
||||
|
||||
##### example
|
||||
```js
|
||||
parseArgv(process.argv);
|
||||
```
|
||||
|
||||
### generateHelp(helpOptions)
|
||||
`generateHelp` produces help text based on your settings.
|
||||
|
||||
##### arguments
|
||||
* helpOptions - `{showHidden: Boolean, interpolate: Object}` - all options optional
|
||||
- `showHidden` specifies whether to show options with `hidden: true` specified, by default it is `false`
|
||||
- `interpolate` specify data to be interpolated in `prepend` and `append` text, `{{key}}` is the format - eg. `generateHelp({interpolate:{version: '0.4.2'}})`, will change this `append` text: `Version {{version}}` to `Version 0.4.2`
|
||||
|
||||
##### returns
|
||||
`String` - the generated help text
|
||||
|
||||
##### example
|
||||
```js
|
||||
generateHelp(); /*
|
||||
"Usage: cmd [options] positional
|
||||
|
||||
-h, --help displays help
|
||||
-c, --count Int number of things
|
||||
|
||||
Version 1.0.0
|
||||
"*/
|
||||
```
|
||||
|
||||
### generateHelpForOption(optionName)
|
||||
`generateHelpForOption` produces expanded help text for the specified with `optionName` option. If an `example` was specified for the option, it will be displayed, and if a `longDescription` was specified, it will display that instead of the `description`.
|
||||
|
||||
##### arguments
|
||||
* optionName - `String` - the name of the option to display
|
||||
|
||||
##### returns
|
||||
`String` - the generated help text for the option
|
||||
|
||||
##### example
|
||||
```js
|
||||
generateHelpForOption('count'); /*
|
||||
"-c, --count Int
|
||||
description: number of things
|
||||
example: cmd --count 2
|
||||
"*/
|
||||
```
|
||||
|
||||
## Settings Format
|
||||
When your `require('optionator')`, you get a function that takes in a settings object. This object has the type:
|
||||
|
||||
{
|
||||
prepend: String,
|
||||
append: String,
|
||||
options: [{heading: String} | {
|
||||
option: String,
|
||||
alias: [String] | String,
|
||||
type: String,
|
||||
enum: [String],
|
||||
default: String,
|
||||
restPositional: Boolean,
|
||||
required: Boolean,
|
||||
overrideRequired: Boolean,
|
||||
dependsOn: [String] | String,
|
||||
concatRepeatedArrays: Boolean | (Boolean, Object),
|
||||
mergeRepeatedObjects: Boolean,
|
||||
description: String,
|
||||
longDescription: String,
|
||||
example: [String] | String
|
||||
}],
|
||||
helpStyle: {
|
||||
aliasSeparator: String,
|
||||
typeSeparator: String,
|
||||
descriptionSeparator: String,
|
||||
initialIndent: Int,
|
||||
secondaryIndent: Int,
|
||||
maxPadFactor: Number
|
||||
},
|
||||
mutuallyExclusive: [[String | [String]]],
|
||||
concatRepeatedArrays: Boolean | (Boolean, Object), // deprecated, set in defaults object
|
||||
mergeRepeatedObjects: Boolean, // deprecated, set in defaults object
|
||||
positionalAnywhere: Boolean,
|
||||
typeAliases: Object,
|
||||
defaults: Object
|
||||
}
|
||||
|
||||
All of the properties are optional (the `Maybe` has been excluded for brevities sake), except for having either `heading: String` or `option: String` in each object in the `options` array.
|
||||
|
||||
### Top Level Properties
|
||||
* `prepend` is an optional string to be placed before the options in the help text
|
||||
* `append` is an optional string to be placed after the options in the help text
|
||||
* `options` is a required array specifying your options and headings, the options and headings will be displayed in the order specified
|
||||
* `helpStyle` is an optional object which enables you to change the default appearance of some aspects of the help text
|
||||
* `mutuallyExclusive` is an optional array of arrays of either strings or arrays of strings. The top level array is a list of rules, each rule is a list of elements - each element can be either a string (the name of an option), or a list of strings (a group of option names) - there will be an error if more than one element is present
|
||||
* `concatRepeatedArrays` see description under the "Option Properties" heading - use at the top level is deprecated, if you want to set this for all options, use the `defaults` property
|
||||
* `mergeRepeatedObjects` see description under the "Option Properties" heading - use at the top level is deprecated, if you want to set this for all options, use the `defaults` property
|
||||
* `positionalAnywhere` is an optional boolean (defaults to `true`) - when `true` it allows positional arguments anywhere, when `false`, all arguments after the first positional one are taken to be positional as well, even if they look like a flag. For example, with `positionalAnywhere: false`, the arguments `--flag --boom 12 --crack` would have two positional arguments: `12` and `--crack`
|
||||
* `typeAliases` is an optional object, it allows you to set aliases for types, eg. `{Path: 'String'}` would allow you to use the type `Path` as an alias for the type `String`
|
||||
* `defaults` is an optional object following the option properties format, which specifies default values for all options. A default will be overridden if manually set. For example, you can do `default: { type: "String" }` to set the default type of all options to `String`, and then override that default in an individual option by setting the `type` property
|
||||
|
||||
#### Heading Properties
|
||||
* `heading` a required string, the name of the heading
|
||||
|
||||
#### Option Properties
|
||||
* `option` the required name of the option - use dash-case, without the leading dashes
|
||||
* `alias` is an optional string or array of strings which specify any aliases for the option
|
||||
* `type` is a required string in the [type check](https://github.com/gkz/type-check) [format](https://github.com/gkz/type-check#type-format), this will be used to cast the inputted value and validate it
|
||||
* `enum` is an optional array of strings, each string will be parsed by [levn](https://github.com/gkz/levn) - the argument value must be one of the resulting values - each potential value must validate against the specified `type`
|
||||
* `default` is a optional string, which will be parsed by [levn](https://github.com/gkz/levn) and used as the default value if none is set - the value must validate against the specified `type`
|
||||
* `restPositional` is an optional boolean - if set to `true`, everything after the option will be taken to be a positional argument, even if it looks like a named argument
|
||||
* `required` is an optional boolean - if set to `true`, the option parsing will fail if the option is not defined
|
||||
* `overrideRequired` is a optional boolean - if set to `true` and the option is used, and there is another option which is required but not set, it will override the need for the required option and there will be no error - this is useful if you have required options and want to use `--help` or `--version` flags
|
||||
* `concatRepeatedArrays` is an optional boolean or tuple with boolean and options object (defaults to `false`) - when set to `true` and an option contains an array value and is repeated, the subsequent values for the flag will be appended rather than overwriting the original value - eg. option `g` of type `[String]`: `-g a -g b -g c,d` will result in `['a','b','c','d']`
|
||||
|
||||
You can supply an options object by giving the following value: `[true, options]`. The one currently supported option is `oneValuePerFlag`, this only allows one array value per flag. This is useful if your potential values contain a comma.
|
||||
* `mergeRepeatedObjects` is an optional boolean (defaults to `false`) - when set to `true` and an option contains an object value and is repeated, the subsequent values for the flag will be merged rather than overwriting the original value - eg. option `g` of type `Object`: `-g a:1 -g b:2 -g c:3,d:4` will result in `{a: 1, b: 2, c: 3, d: 4}`
|
||||
* `dependsOn` is an optional string or array of strings - if simply a string (the name of another option), it will make sure that that other option is set, if an array of strings, depending on whether `'and'` or `'or'` is first, it will either check whether all (`['and', 'option-a', 'option-b']`), or at least one (`['or', 'option-a', 'option-b']`) other options are set
|
||||
* `description` is an optional string, which will be displayed next to the option in the help text
|
||||
* `longDescription` is an optional string, it will be displayed instead of the `description` when `generateHelpForOption` is used
|
||||
* `example` is an optional string or array of strings with example(s) for the option - these will be displayed when `generateHelpForOption` is used
|
||||
|
||||
#### Help Style Properties
|
||||
* `aliasSeparator` is an optional string, separates multiple names from each other - default: ' ,'
|
||||
* `typeSeparator` is an optional string, separates the type from the names - default: ' '
|
||||
* `descriptionSeparator` is an optional string , separates the description from the padded name and type - default: ' '
|
||||
* `initialIndent` is an optional int - the amount of indent for options - default: 2
|
||||
* `secondaryIndent` is an optional int - the amount of indent if wrapped fully (in addition to the initial indent) - default: 4
|
||||
* `maxPadFactor` is an optional number - affects the default level of padding for the names/type, it is multiplied by the average of the length of the names/type - default: 1.5
|
||||
|
||||
## Argument Format
|
||||
At the highest level there are two types of arguments: named, and positional.
|
||||
|
||||
Name arguments of any length are prefixed with `--` (eg. `--go`), and those of one character may be prefixed with either `--` or `-` (eg. `-g`).
|
||||
|
||||
There are two types of named arguments: boolean flags (eg. `--problemo`, `-p`) which take no value and result in a `true` if they are present, the falsey `undefined` if they are not present, or `false` if present and explicitly prefixed with `no` (eg. `--no-problemo`). Named arguments with values (eg. `--tseries 800`, `-t 800`) are the other type. If the option has a type `Boolean` it will automatically be made into a boolean flag. Any other type results in a named argument that takes a value.
|
||||
|
||||
For more information about how to properly set types to get the value you want, take a look at the [type check](https://github.com/gkz/type-check) and [levn](https://github.com/gkz/levn) pages.
|
||||
|
||||
You can group single character arguments that use a single `-`, however all except the last must be boolean flags (which take no value). The last may be a boolean flag, or an argument which takes a value - eg. `-ba 2` is equivalent to `-b -a 2`.
|
||||
|
||||
Positional arguments are all those values which do not fall under the above - they can be anywhere, not just at the end. For example, in `cmd -b one -a 2 two` where `b` is a boolean flag, and `a` has the type `Number`, there are two positional arguments, `one` and `two`.
|
||||
|
||||
Everything after an `--` is positional, even if it looks like a named argument.
|
||||
|
||||
You may optionally use `=` to separate option names from values, for example: `--count=2`.
|
||||
|
||||
If you specify the option `NUM`, then any argument using a single `-` followed by a number will be valid and will set the value of `NUM`. Eg. `-2` will be parsed into `NUM: 2`.
|
||||
|
||||
If duplicate named arguments are present, the last one will be taken.
|
||||
|
||||
## Technical About
|
||||
`optionator` is written in [LiveScript](http://livescript.net/) - a language that compiles to JavaScript. It uses [levn](https://github.com/gkz/levn) to cast arguments to their specified type, and uses [type-check](https://github.com/gkz/type-check) to validate values. It also uses the [prelude.ls](http://preludels.com/) library.
|
||||
@@ -0,0 +1,21 @@
|
||||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) 2011 Einar Otto Stangvik <einaros@gmail.com>
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
@@ -0,0 +1,392 @@
|
||||
/**
|
||||
* Argon2 KDF from RFC 9106. Can be used to create a key from password and salt.
|
||||
* We suggest to use Scrypt. JS Argon is 2-10x slower than native code because of 64-bitness:
|
||||
* * argon uses uint64, but JS doesn't have fast uint64array
|
||||
* * uint64 multiplication is 1/3 of time
|
||||
* * `P` function would be very nice with u64, because most of value will be in registers,
|
||||
* hovewer with u32 it will require 32 registers, which is too much.
|
||||
* * JS arrays do slow bound checks, so reading from `A2_BUF` slows it down
|
||||
* @module
|
||||
*/
|
||||
import { add3H, add3L, rotr32H, rotr32L, rotrBH, rotrBL, rotrSH, rotrSL } from "./_u64.js";
|
||||
import { blake2b } from "./blake2.js";
|
||||
import { abytes, clean, kdfInputToBytes, nextTick, u32, u8 } from "./utils.js";
|
||||
const AT = { Argond2d: 0, Argon2i: 1, Argon2id: 2 };
|
||||
const ARGON2_SYNC_POINTS = 4;
|
||||
const abytesOrZero = (buf) => {
|
||||
if (buf === undefined)
|
||||
return Uint8Array.of();
|
||||
return kdfInputToBytes(buf);
|
||||
};
|
||||
// u32 * u32 = u64
|
||||
function mul(a, b) {
|
||||
const aL = a & 0xffff;
|
||||
const aH = a >>> 16;
|
||||
const bL = b & 0xffff;
|
||||
const bH = b >>> 16;
|
||||
const ll = Math.imul(aL, bL);
|
||||
const hl = Math.imul(aH, bL);
|
||||
const lh = Math.imul(aL, bH);
|
||||
const hh = Math.imul(aH, bH);
|
||||
const carry = (ll >>> 16) + (hl & 0xffff) + lh;
|
||||
const high = (hh + (hl >>> 16) + (carry >>> 16)) | 0;
|
||||
const low = (carry << 16) | (ll & 0xffff);
|
||||
return { h: high, l: low };
|
||||
}
|
||||
function mul2(a, b) {
|
||||
// 2 * a * b (via shifts)
|
||||
const { h, l } = mul(a, b);
|
||||
return { h: ((h << 1) | (l >>> 31)) & 4294967295, l: (l << 1) & 4294967295 };
|
||||
}
|
||||
// BlaMka permutation for Argon2
|
||||
// A + B + (2 * u32(A) * u32(B))
|
||||
function blamka(Ah, Al, Bh, Bl) {
|
||||
const { h: Ch, l: Cl } = mul2(Al, Bl);
|
||||
// A + B + (2 * A * B)
|
||||
const Rll = add3L(Al, Bl, Cl);
|
||||
return { h: add3H(Rll, Ah, Bh, Ch), l: Rll | 0 };
|
||||
}
|
||||
// Temporary block buffer
|
||||
const A2_BUF = new Uint32Array(256); // 1024 bytes (matrix 16x16)
|
||||
function G(a, b, c, d) {
|
||||
let Al = A2_BUF[2 * a], Ah = A2_BUF[2 * a + 1]; // prettier-ignore
|
||||
let Bl = A2_BUF[2 * b], Bh = A2_BUF[2 * b + 1]; // prettier-ignore
|
||||
let Cl = A2_BUF[2 * c], Ch = A2_BUF[2 * c + 1]; // prettier-ignore
|
||||
let Dl = A2_BUF[2 * d], Dh = A2_BUF[2 * d + 1]; // prettier-ignore
|
||||
({ h: Ah, l: Al } = blamka(Ah, Al, Bh, Bl));
|
||||
({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
|
||||
({ Dh, Dl } = { Dh: rotr32H(Dh, Dl), Dl: rotr32L(Dh, Dl) });
|
||||
({ h: Ch, l: Cl } = blamka(Ch, Cl, Dh, Dl));
|
||||
({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
|
||||
({ Bh, Bl } = { Bh: rotrSH(Bh, Bl, 24), Bl: rotrSL(Bh, Bl, 24) });
|
||||
({ h: Ah, l: Al } = blamka(Ah, Al, Bh, Bl));
|
||||
({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
|
||||
({ Dh, Dl } = { Dh: rotrSH(Dh, Dl, 16), Dl: rotrSL(Dh, Dl, 16) });
|
||||
({ h: Ch, l: Cl } = blamka(Ch, Cl, Dh, Dl));
|
||||
({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
|
||||
({ Bh, Bl } = { Bh: rotrBH(Bh, Bl, 63), Bl: rotrBL(Bh, Bl, 63) });
|
||||
(A2_BUF[2 * a] = Al), (A2_BUF[2 * a + 1] = Ah);
|
||||
(A2_BUF[2 * b] = Bl), (A2_BUF[2 * b + 1] = Bh);
|
||||
(A2_BUF[2 * c] = Cl), (A2_BUF[2 * c + 1] = Ch);
|
||||
(A2_BUF[2 * d] = Dl), (A2_BUF[2 * d + 1] = Dh);
|
||||
}
|
||||
// prettier-ignore
|
||||
function P(v00, v01, v02, v03, v04, v05, v06, v07, v08, v09, v10, v11, v12, v13, v14, v15) {
|
||||
G(v00, v04, v08, v12);
|
||||
G(v01, v05, v09, v13);
|
||||
G(v02, v06, v10, v14);
|
||||
G(v03, v07, v11, v15);
|
||||
G(v00, v05, v10, v15);
|
||||
G(v01, v06, v11, v12);
|
||||
G(v02, v07, v08, v13);
|
||||
G(v03, v04, v09, v14);
|
||||
}
|
||||
function block(x, xPos, yPos, outPos, needXor) {
|
||||
for (let i = 0; i < 256; i++)
|
||||
A2_BUF[i] = x[xPos + i] ^ x[yPos + i];
|
||||
// columns (8)
|
||||
for (let i = 0; i < 128; i += 16) {
|
||||
// prettier-ignore
|
||||
P(i, i + 1, i + 2, i + 3, i + 4, i + 5, i + 6, i + 7, i + 8, i + 9, i + 10, i + 11, i + 12, i + 13, i + 14, i + 15);
|
||||
}
|
||||
// rows (8)
|
||||
for (let i = 0; i < 16; i += 2) {
|
||||
// prettier-ignore
|
||||
P(i, i + 1, i + 16, i + 17, i + 32, i + 33, i + 48, i + 49, i + 64, i + 65, i + 80, i + 81, i + 96, i + 97, i + 112, i + 113);
|
||||
}
|
||||
if (needXor)
|
||||
for (let i = 0; i < 256; i++)
|
||||
x[outPos + i] ^= A2_BUF[i] ^ x[xPos + i] ^ x[yPos + i];
|
||||
else
|
||||
for (let i = 0; i < 256; i++)
|
||||
x[outPos + i] = A2_BUF[i] ^ x[xPos + i] ^ x[yPos + i];
|
||||
clean(A2_BUF);
|
||||
}
|
||||
// Variable-Length Hash Function H'
|
||||
function Hp(A, dkLen) {
|
||||
const A8 = u8(A);
|
||||
const T = new Uint32Array(1);
|
||||
const T8 = u8(T);
|
||||
T[0] = dkLen;
|
||||
// Fast path
|
||||
if (dkLen <= 64)
|
||||
return blake2b.create({ dkLen }).update(T8).update(A8).digest();
|
||||
const out = new Uint8Array(dkLen);
|
||||
let V = blake2b.create({}).update(T8).update(A8).digest();
|
||||
let pos = 0;
|
||||
// First block
|
||||
out.set(V.subarray(0, 32));
|
||||
pos += 32;
|
||||
// Rest blocks
|
||||
for (; dkLen - pos > 64; pos += 32) {
|
||||
const Vh = blake2b.create({}).update(V);
|
||||
Vh.digestInto(V);
|
||||
Vh.destroy();
|
||||
out.set(V.subarray(0, 32), pos);
|
||||
}
|
||||
// Last block
|
||||
out.set(blake2b(V, { dkLen: dkLen - pos }), pos);
|
||||
clean(V, T);
|
||||
return u32(out);
|
||||
}
|
||||
// Used only inside process block!
|
||||
function indexAlpha(r, s, laneLen, segmentLen, index, randL, sameLane = false) {
|
||||
// This is ugly, but close enough to reference implementation.
|
||||
let area;
|
||||
if (r === 0) {
|
||||
if (s === 0)
|
||||
area = index - 1;
|
||||
else if (sameLane)
|
||||
area = s * segmentLen + index - 1;
|
||||
else
|
||||
area = s * segmentLen + (index == 0 ? -1 : 0);
|
||||
}
|
||||
else if (sameLane)
|
||||
area = laneLen - segmentLen + index - 1;
|
||||
else
|
||||
area = laneLen - segmentLen + (index == 0 ? -1 : 0);
|
||||
const startPos = r !== 0 && s !== ARGON2_SYNC_POINTS - 1 ? (s + 1) * segmentLen : 0;
|
||||
const rel = area - 1 - mul(area, mul(randL, randL).h).h;
|
||||
return (startPos + rel) % laneLen;
|
||||
}
|
||||
const maxUint32 = Math.pow(2, 32);
|
||||
function isU32(num) {
|
||||
return Number.isSafeInteger(num) && num >= 0 && num < maxUint32;
|
||||
}
|
||||
function argon2Opts(opts) {
|
||||
const merged = {
|
||||
version: 0x13,
|
||||
dkLen: 32,
|
||||
maxmem: maxUint32 - 1,
|
||||
asyncTick: 10,
|
||||
};
|
||||
for (let [k, v] of Object.entries(opts))
|
||||
if (v != null)
|
||||
merged[k] = v;
|
||||
const { dkLen, p, m, t, version, onProgress } = merged;
|
||||
if (!isU32(dkLen) || dkLen < 4)
|
||||
throw new Error('dkLen should be at least 4 bytes');
|
||||
if (!isU32(p) || p < 1 || p >= Math.pow(2, 24))
|
||||
throw new Error('p should be 1 <= p < 2^24');
|
||||
if (!isU32(m))
|
||||
throw new Error('m should be 0 <= m < 2^32');
|
||||
if (!isU32(t) || t < 1)
|
||||
throw new Error('t (iterations) should be 1 <= t < 2^32');
|
||||
if (onProgress !== undefined && typeof onProgress !== 'function')
|
||||
throw new Error('progressCb should be function');
|
||||
/*
|
||||
Memory size m MUST be an integer number of kibibytes from 8*p to 2^(32)-1. The actual number of blocks is m', which is m rounded down to the nearest multiple of 4*p.
|
||||
*/
|
||||
if (!isU32(m) || m < 8 * p)
|
||||
throw new Error('memory should be at least 8*p bytes');
|
||||
if (version !== 0x10 && version !== 0x13)
|
||||
throw new Error('unknown version=' + version);
|
||||
return merged;
|
||||
}
|
||||
function argon2Init(password, salt, type, opts) {
|
||||
password = kdfInputToBytes(password);
|
||||
salt = kdfInputToBytes(salt);
|
||||
abytes(password);
|
||||
abytes(salt);
|
||||
if (!isU32(password.length))
|
||||
throw new Error('password should be less than 4 GB');
|
||||
if (!isU32(salt.length) || salt.length < 8)
|
||||
throw new Error('salt should be at least 8 bytes and less than 4 GB');
|
||||
if (!Object.values(AT).includes(type))
|
||||
throw new Error('invalid type');
|
||||
let { p, dkLen, m, t, version, key, personalization, maxmem, onProgress, asyncTick } = argon2Opts(opts);
|
||||
// Validation
|
||||
key = abytesOrZero(key);
|
||||
personalization = abytesOrZero(personalization);
|
||||
// H_0 = H^(64)(LE32(p) || LE32(T) || LE32(m) || LE32(t) ||
|
||||
// LE32(v) || LE32(y) || LE32(length(P)) || P ||
|
||||
// LE32(length(S)) || S || LE32(length(K)) || K ||
|
||||
// LE32(length(X)) || X)
|
||||
const h = blake2b.create({});
|
||||
const BUF = new Uint32Array(1);
|
||||
const BUF8 = u8(BUF);
|
||||
for (let item of [p, dkLen, m, t, version, type]) {
|
||||
BUF[0] = item;
|
||||
h.update(BUF8);
|
||||
}
|
||||
for (let i of [password, salt, key, personalization]) {
|
||||
BUF[0] = i.length; // BUF is u32 array, this is valid
|
||||
h.update(BUF8).update(i);
|
||||
}
|
||||
const H0 = new Uint32Array(18);
|
||||
const H0_8 = u8(H0);
|
||||
h.digestInto(H0_8);
|
||||
// 256 u32 = 1024 (BLOCK_SIZE), fills A2_BUF on processing
|
||||
// Params
|
||||
const lanes = p;
|
||||
// m' = 4 * p * floor (m / 4p)
|
||||
const mP = 4 * p * Math.floor(m / (ARGON2_SYNC_POINTS * p));
|
||||
//q = m' / p columns
|
||||
const laneLen = Math.floor(mP / p);
|
||||
const segmentLen = Math.floor(laneLen / ARGON2_SYNC_POINTS);
|
||||
const memUsed = mP * 256;
|
||||
if (!isU32(maxmem) || memUsed > maxmem)
|
||||
throw new Error('mem should be less than 2**32, got: maxmem=' + maxmem + ', memused=' + memUsed);
|
||||
const B = new Uint32Array(memUsed);
|
||||
// Fill first blocks
|
||||
for (let l = 0; l < p; l++) {
|
||||
const i = 256 * laneLen * l;
|
||||
// B[i][0] = H'^(1024)(H_0 || LE32(0) || LE32(i))
|
||||
H0[17] = l;
|
||||
H0[16] = 0;
|
||||
B.set(Hp(H0, 1024), i);
|
||||
// B[i][1] = H'^(1024)(H_0 || LE32(1) || LE32(i))
|
||||
H0[16] = 1;
|
||||
B.set(Hp(H0, 1024), i + 256);
|
||||
}
|
||||
let perBlock = () => { };
|
||||
if (onProgress) {
|
||||
const totalBlock = t * ARGON2_SYNC_POINTS * p * segmentLen;
|
||||
// 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(totalBlock / 10000), 1);
|
||||
let blockCnt = 0;
|
||||
perBlock = () => {
|
||||
blockCnt++;
|
||||
if (onProgress && (!(blockCnt % callbackPer) || blockCnt === totalBlock))
|
||||
onProgress(blockCnt / totalBlock);
|
||||
};
|
||||
}
|
||||
clean(BUF, H0);
|
||||
return { type, mP, p, t, version, B, laneLen, lanes, segmentLen, dkLen, perBlock, asyncTick };
|
||||
}
|
||||
function argon2Output(B, p, laneLen, dkLen) {
|
||||
const B_final = new Uint32Array(256);
|
||||
for (let l = 0; l < p; l++)
|
||||
for (let j = 0; j < 256; j++)
|
||||
B_final[j] ^= B[256 * (laneLen * l + laneLen - 1) + j];
|
||||
const res = u8(Hp(B_final, dkLen));
|
||||
clean(B_final);
|
||||
return res;
|
||||
}
|
||||
function processBlock(B, address, l, r, s, index, laneLen, segmentLen, lanes, offset, prev, dataIndependent, needXor) {
|
||||
if (offset % laneLen)
|
||||
prev = offset - 1;
|
||||
let randL, randH;
|
||||
if (dataIndependent) {
|
||||
let i128 = index % 128;
|
||||
if (i128 === 0) {
|
||||
address[256 + 12]++;
|
||||
block(address, 256, 2 * 256, 0, false);
|
||||
block(address, 0, 2 * 256, 0, false);
|
||||
}
|
||||
randL = address[2 * i128];
|
||||
randH = address[2 * i128 + 1];
|
||||
}
|
||||
else {
|
||||
const T = 256 * prev;
|
||||
randL = B[T];
|
||||
randH = B[T + 1];
|
||||
}
|
||||
// address block
|
||||
const refLane = r === 0 && s === 0 ? l : randH % lanes;
|
||||
const refPos = indexAlpha(r, s, laneLen, segmentLen, index, randL, refLane == l);
|
||||
const refBlock = laneLen * refLane + refPos;
|
||||
// B[i][j] = G(B[i][j-1], B[l][z])
|
||||
block(B, 256 * prev, 256 * refBlock, offset * 256, needXor);
|
||||
}
|
||||
function argon2(type, password, salt, opts) {
|
||||
const { mP, p, t, version, B, laneLen, lanes, segmentLen, dkLen, perBlock } = argon2Init(password, salt, type, opts);
|
||||
// Pre-loop setup
|
||||
// [address, input, zero_block] format so we can pass single U32 to block function
|
||||
const address = new Uint32Array(3 * 256);
|
||||
address[256 + 6] = mP;
|
||||
address[256 + 8] = t;
|
||||
address[256 + 10] = type;
|
||||
for (let r = 0; r < t; r++) {
|
||||
const needXor = r !== 0 && version === 0x13;
|
||||
address[256 + 0] = r;
|
||||
for (let s = 0; s < ARGON2_SYNC_POINTS; s++) {
|
||||
address[256 + 4] = s;
|
||||
const dataIndependent = type == AT.Argon2i || (type == AT.Argon2id && r === 0 && s < 2);
|
||||
for (let l = 0; l < p; l++) {
|
||||
address[256 + 2] = l;
|
||||
address[256 + 12] = 0;
|
||||
let startPos = 0;
|
||||
if (r === 0 && s === 0) {
|
||||
startPos = 2;
|
||||
if (dataIndependent) {
|
||||
address[256 + 12]++;
|
||||
block(address, 256, 2 * 256, 0, false);
|
||||
block(address, 0, 2 * 256, 0, false);
|
||||
}
|
||||
}
|
||||
// current block postion
|
||||
let offset = l * laneLen + s * segmentLen + startPos;
|
||||
// previous block position
|
||||
let prev = offset % laneLen ? offset - 1 : offset + laneLen - 1;
|
||||
for (let index = startPos; index < segmentLen; index++, offset++, prev++) {
|
||||
perBlock();
|
||||
processBlock(B, address, l, r, s, index, laneLen, segmentLen, lanes, offset, prev, dataIndependent, needXor);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
clean(address);
|
||||
return argon2Output(B, p, laneLen, dkLen);
|
||||
}
|
||||
/** argon2d GPU-resistant version. */
|
||||
export const argon2d = (password, salt, opts) => argon2(AT.Argond2d, password, salt, opts);
|
||||
/** argon2i side-channel-resistant version. */
|
||||
export const argon2i = (password, salt, opts) => argon2(AT.Argon2i, password, salt, opts);
|
||||
/** argon2id, combining i+d, the most popular version from RFC 9106 */
|
||||
export const argon2id = (password, salt, opts) => argon2(AT.Argon2id, password, salt, opts);
|
||||
async function argon2Async(type, password, salt, opts) {
|
||||
const { mP, p, t, version, B, laneLen, lanes, segmentLen, dkLen, perBlock, asyncTick } = argon2Init(password, salt, type, opts);
|
||||
// Pre-loop setup
|
||||
// [address, input, zero_block] format so we can pass single U32 to block function
|
||||
const address = new Uint32Array(3 * 256);
|
||||
address[256 + 6] = mP;
|
||||
address[256 + 8] = t;
|
||||
address[256 + 10] = type;
|
||||
let ts = Date.now();
|
||||
for (let r = 0; r < t; r++) {
|
||||
const needXor = r !== 0 && version === 0x13;
|
||||
address[256 + 0] = r;
|
||||
for (let s = 0; s < ARGON2_SYNC_POINTS; s++) {
|
||||
address[256 + 4] = s;
|
||||
const dataIndependent = type == AT.Argon2i || (type == AT.Argon2id && r === 0 && s < 2);
|
||||
for (let l = 0; l < p; l++) {
|
||||
address[256 + 2] = l;
|
||||
address[256 + 12] = 0;
|
||||
let startPos = 0;
|
||||
if (r === 0 && s === 0) {
|
||||
startPos = 2;
|
||||
if (dataIndependent) {
|
||||
address[256 + 12]++;
|
||||
block(address, 256, 2 * 256, 0, false);
|
||||
block(address, 0, 2 * 256, 0, false);
|
||||
}
|
||||
}
|
||||
// current block postion
|
||||
let offset = l * laneLen + s * segmentLen + startPos;
|
||||
// previous block position
|
||||
let prev = offset % laneLen ? offset - 1 : offset + laneLen - 1;
|
||||
for (let index = startPos; index < segmentLen; index++, offset++, prev++) {
|
||||
perBlock();
|
||||
processBlock(B, address, l, r, s, index, laneLen, segmentLen, lanes, offset, prev, dataIndependent, needXor);
|
||||
// Date.now() is not monotonic, so in case if clock goes backwards we return return control too
|
||||
const diff = Date.now() - ts;
|
||||
if (!(diff >= 0 && diff < asyncTick)) {
|
||||
await nextTick();
|
||||
ts += diff;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
clean(address);
|
||||
return argon2Output(B, p, laneLen, dkLen);
|
||||
}
|
||||
/** argon2d async GPU-resistant version. */
|
||||
export const argon2dAsync = (password, salt, opts) => argon2Async(AT.Argond2d, password, salt, opts);
|
||||
/** argon2i async side-channel-resistant version. */
|
||||
export const argon2iAsync = (password, salt, opts) => argon2Async(AT.Argon2i, password, salt, opts);
|
||||
/** argon2id async, combining i+d, the most popular version from RFC 9106 */
|
||||
export const argon2idAsync = (password, salt, opts) => argon2Async(AT.Argon2id, password, salt, opts);
|
||||
//# sourceMappingURL=argon2.js.map
|
||||
@@ -0,0 +1,14 @@
|
||||
import { Writable } from 'node:stream'
|
||||
|
||||
export default (): Writable => {
|
||||
const myTransportStream = new Writable({
|
||||
autoDestroy: true,
|
||||
write (chunk, _enc, cb) {
|
||||
console.log(chunk.toString())
|
||||
cb()
|
||||
},
|
||||
defaultEncoding: 'utf8'
|
||||
})
|
||||
|
||||
return myTransportStream
|
||||
}
|
||||
@@ -0,0 +1,78 @@
|
||||
{
|
||||
"name": "semver",
|
||||
"version": "7.8.5",
|
||||
"description": "The semantic version parser used by npm.",
|
||||
"main": "index.js",
|
||||
"scripts": {
|
||||
"test": "tap",
|
||||
"snap": "tap",
|
||||
"lint": "npm run eslint",
|
||||
"postlint": "template-oss-check",
|
||||
"lintfix": "npm run eslint -- --fix",
|
||||
"posttest": "npm run lint",
|
||||
"template-oss-apply": "template-oss-apply --force",
|
||||
"eslint": "eslint \"**/*.{js,cjs,ts,mjs,jsx,tsx}\""
|
||||
},
|
||||
"devDependencies": {
|
||||
"@npmcli/eslint-config": "^7.0.0",
|
||||
"@npmcli/template-oss": "5.0.0",
|
||||
"benchmark": "^2.1.4",
|
||||
"tap": "^16.0.0"
|
||||
},
|
||||
"license": "ISC",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git+https://github.com/npm/node-semver.git"
|
||||
},
|
||||
"bin": {
|
||||
"semver": "bin/semver.js"
|
||||
},
|
||||
"files": [
|
||||
"bin/",
|
||||
"lib/",
|
||||
"classes/",
|
||||
"functions/",
|
||||
"internal/",
|
||||
"ranges/",
|
||||
"index.js",
|
||||
"preload.js",
|
||||
"range.bnf"
|
||||
],
|
||||
"tap": {
|
||||
"timeout": 30,
|
||||
"coverage-map": "map.js",
|
||||
"nyc-arg": [
|
||||
"--exclude",
|
||||
"tap-snapshots/**"
|
||||
]
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=10"
|
||||
},
|
||||
"author": "GitHub Inc.",
|
||||
"templateOSS": {
|
||||
"//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
|
||||
"version": "5.0.0",
|
||||
"engines": ">=10",
|
||||
"distPaths": [
|
||||
"classes/",
|
||||
"functions/",
|
||||
"internal/",
|
||||
"ranges/",
|
||||
"index.js",
|
||||
"preload.js",
|
||||
"range.bnf"
|
||||
],
|
||||
"allowPaths": [
|
||||
"/classes/",
|
||||
"/functions/",
|
||||
"/internal/",
|
||||
"/ranges/",
|
||||
"/index.js",
|
||||
"/preload.js",
|
||||
"/range.bnf",
|
||||
"/benchmarks"
|
||||
],
|
||||
"publish": "true"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,287 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.ripemd160 = exports.RIPEMD160 = exports.md5 = exports.MD5 = exports.sha1 = exports.SHA1 = void 0;
|
||||
/**
|
||||
|
||||
SHA1 (RFC 3174), MD5 (RFC 1321) and RIPEMD160 (RFC 2286) legacy, weak hash functions.
|
||||
Don't use them in a new protocol. What "weak" means:
|
||||
|
||||
- Collisions can be made with 2^18 effort in MD5, 2^60 in SHA1, 2^80 in RIPEMD160.
|
||||
- No practical pre-image attacks (only theoretical, 2^123.4)
|
||||
- HMAC seems kinda ok: https://datatracker.ietf.org/doc/html/rfc6151
|
||||
* @module
|
||||
*/
|
||||
const _md_ts_1 = require("./_md.js");
|
||||
const utils_ts_1 = require("./utils.js");
|
||||
/** Initial SHA1 state */
|
||||
const SHA1_IV = /* @__PURE__ */ Uint32Array.from([
|
||||
0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0,
|
||||
]);
|
||||
// Reusable temporary buffer
|
||||
const SHA1_W = /* @__PURE__ */ new Uint32Array(80);
|
||||
/** SHA1 legacy hash class. */
|
||||
class SHA1 extends _md_ts_1.HashMD {
|
||||
constructor() {
|
||||
super(64, 20, 8, false);
|
||||
this.A = SHA1_IV[0] | 0;
|
||||
this.B = SHA1_IV[1] | 0;
|
||||
this.C = SHA1_IV[2] | 0;
|
||||
this.D = SHA1_IV[3] | 0;
|
||||
this.E = SHA1_IV[4] | 0;
|
||||
}
|
||||
get() {
|
||||
const { A, B, C, D, E } = this;
|
||||
return [A, B, C, D, E];
|
||||
}
|
||||
set(A, B, C, D, E) {
|
||||
this.A = A | 0;
|
||||
this.B = B | 0;
|
||||
this.C = C | 0;
|
||||
this.D = D | 0;
|
||||
this.E = E | 0;
|
||||
}
|
||||
process(view, offset) {
|
||||
for (let i = 0; i < 16; i++, offset += 4)
|
||||
SHA1_W[i] = view.getUint32(offset, false);
|
||||
for (let i = 16; i < 80; i++)
|
||||
SHA1_W[i] = (0, utils_ts_1.rotl)(SHA1_W[i - 3] ^ SHA1_W[i - 8] ^ SHA1_W[i - 14] ^ SHA1_W[i - 16], 1);
|
||||
// Compression function main loop, 80 rounds
|
||||
let { A, B, C, D, E } = this;
|
||||
for (let i = 0; i < 80; i++) {
|
||||
let F, K;
|
||||
if (i < 20) {
|
||||
F = (0, _md_ts_1.Chi)(B, C, D);
|
||||
K = 0x5a827999;
|
||||
}
|
||||
else if (i < 40) {
|
||||
F = B ^ C ^ D;
|
||||
K = 0x6ed9eba1;
|
||||
}
|
||||
else if (i < 60) {
|
||||
F = (0, _md_ts_1.Maj)(B, C, D);
|
||||
K = 0x8f1bbcdc;
|
||||
}
|
||||
else {
|
||||
F = B ^ C ^ D;
|
||||
K = 0xca62c1d6;
|
||||
}
|
||||
const T = ((0, utils_ts_1.rotl)(A, 5) + F + E + K + SHA1_W[i]) | 0;
|
||||
E = D;
|
||||
D = C;
|
||||
C = (0, utils_ts_1.rotl)(B, 30);
|
||||
B = A;
|
||||
A = T;
|
||||
}
|
||||
// Add the compressed chunk to the current hash value
|
||||
A = (A + this.A) | 0;
|
||||
B = (B + this.B) | 0;
|
||||
C = (C + this.C) | 0;
|
||||
D = (D + this.D) | 0;
|
||||
E = (E + this.E) | 0;
|
||||
this.set(A, B, C, D, E);
|
||||
}
|
||||
roundClean() {
|
||||
(0, utils_ts_1.clean)(SHA1_W);
|
||||
}
|
||||
destroy() {
|
||||
this.set(0, 0, 0, 0, 0);
|
||||
(0, utils_ts_1.clean)(this.buffer);
|
||||
}
|
||||
}
|
||||
exports.SHA1 = SHA1;
|
||||
/** SHA1 (RFC 3174) legacy hash function. It was cryptographically broken. */
|
||||
exports.sha1 = (0, utils_ts_1.createHasher)(() => new SHA1());
|
||||
/** Per-round constants */
|
||||
const p32 = /* @__PURE__ */ Math.pow(2, 32);
|
||||
const K = /* @__PURE__ */ Array.from({ length: 64 }, (_, i) => Math.floor(p32 * Math.abs(Math.sin(i + 1))));
|
||||
/** md5 initial state: same as sha1, but 4 u32 instead of 5. */
|
||||
const MD5_IV = /* @__PURE__ */ SHA1_IV.slice(0, 4);
|
||||
// Reusable temporary buffer
|
||||
const MD5_W = /* @__PURE__ */ new Uint32Array(16);
|
||||
/** MD5 legacy hash class. */
|
||||
class MD5 extends _md_ts_1.HashMD {
|
||||
constructor() {
|
||||
super(64, 16, 8, true);
|
||||
this.A = MD5_IV[0] | 0;
|
||||
this.B = MD5_IV[1] | 0;
|
||||
this.C = MD5_IV[2] | 0;
|
||||
this.D = MD5_IV[3] | 0;
|
||||
}
|
||||
get() {
|
||||
const { A, B, C, D } = this;
|
||||
return [A, B, C, D];
|
||||
}
|
||||
set(A, B, C, D) {
|
||||
this.A = A | 0;
|
||||
this.B = B | 0;
|
||||
this.C = C | 0;
|
||||
this.D = D | 0;
|
||||
}
|
||||
process(view, offset) {
|
||||
for (let i = 0; i < 16; i++, offset += 4)
|
||||
MD5_W[i] = view.getUint32(offset, true);
|
||||
// Compression function main loop, 64 rounds
|
||||
let { A, B, C, D } = this;
|
||||
for (let i = 0; i < 64; i++) {
|
||||
let F, g, s;
|
||||
if (i < 16) {
|
||||
F = (0, _md_ts_1.Chi)(B, C, D);
|
||||
g = i;
|
||||
s = [7, 12, 17, 22];
|
||||
}
|
||||
else if (i < 32) {
|
||||
F = (0, _md_ts_1.Chi)(D, B, C);
|
||||
g = (5 * i + 1) % 16;
|
||||
s = [5, 9, 14, 20];
|
||||
}
|
||||
else if (i < 48) {
|
||||
F = B ^ C ^ D;
|
||||
g = (3 * i + 5) % 16;
|
||||
s = [4, 11, 16, 23];
|
||||
}
|
||||
else {
|
||||
F = C ^ (B | ~D);
|
||||
g = (7 * i) % 16;
|
||||
s = [6, 10, 15, 21];
|
||||
}
|
||||
F = F + A + K[i] + MD5_W[g];
|
||||
A = D;
|
||||
D = C;
|
||||
C = B;
|
||||
B = B + (0, utils_ts_1.rotl)(F, s[i % 4]);
|
||||
}
|
||||
// Add the compressed chunk to the current hash value
|
||||
A = (A + this.A) | 0;
|
||||
B = (B + this.B) | 0;
|
||||
C = (C + this.C) | 0;
|
||||
D = (D + this.D) | 0;
|
||||
this.set(A, B, C, D);
|
||||
}
|
||||
roundClean() {
|
||||
(0, utils_ts_1.clean)(MD5_W);
|
||||
}
|
||||
destroy() {
|
||||
this.set(0, 0, 0, 0);
|
||||
(0, utils_ts_1.clean)(this.buffer);
|
||||
}
|
||||
}
|
||||
exports.MD5 = MD5;
|
||||
/**
|
||||
* MD5 (RFC 1321) legacy hash function. It was cryptographically broken.
|
||||
* MD5 architecture is similar to SHA1, with some differences:
|
||||
* - Reduced output length: 16 bytes (128 bit) instead of 20
|
||||
* - 64 rounds, instead of 80
|
||||
* - Little-endian: could be faster, but will require more code
|
||||
* - Non-linear index selection: huge speed-up for unroll
|
||||
* - Per round constants: more memory accesses, additional speed-up for unroll
|
||||
*/
|
||||
exports.md5 = (0, utils_ts_1.createHasher)(() => new MD5());
|
||||
// RIPEMD-160
|
||||
const Rho160 = /* @__PURE__ */ Uint8Array.from([
|
||||
7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
|
||||
]);
|
||||
const Id160 = /* @__PURE__ */ (() => Uint8Array.from(new Array(16).fill(0).map((_, i) => i)))();
|
||||
const Pi160 = /* @__PURE__ */ (() => Id160.map((i) => (9 * i + 5) % 16))();
|
||||
const idxLR = /* @__PURE__ */ (() => {
|
||||
const L = [Id160];
|
||||
const R = [Pi160];
|
||||
const res = [L, R];
|
||||
for (let i = 0; i < 4; i++)
|
||||
for (let j of res)
|
||||
j.push(j[i].map((k) => Rho160[k]));
|
||||
return res;
|
||||
})();
|
||||
const idxL = /* @__PURE__ */ (() => idxLR[0])();
|
||||
const idxR = /* @__PURE__ */ (() => idxLR[1])();
|
||||
// const [idxL, idxR] = idxLR;
|
||||
const shifts160 = /* @__PURE__ */ [
|
||||
[11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
|
||||
[12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
|
||||
[13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
|
||||
[14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
|
||||
[15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5],
|
||||
].map((i) => Uint8Array.from(i));
|
||||
const shiftsL160 = /* @__PURE__ */ idxL.map((idx, i) => idx.map((j) => shifts160[i][j]));
|
||||
const shiftsR160 = /* @__PURE__ */ idxR.map((idx, i) => idx.map((j) => shifts160[i][j]));
|
||||
const Kl160 = /* @__PURE__ */ Uint32Array.from([
|
||||
0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e,
|
||||
]);
|
||||
const Kr160 = /* @__PURE__ */ Uint32Array.from([
|
||||
0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000,
|
||||
]);
|
||||
// It's called f() in spec.
|
||||
function ripemd_f(group, x, y, z) {
|
||||
if (group === 0)
|
||||
return x ^ y ^ z;
|
||||
if (group === 1)
|
||||
return (x & y) | (~x & z);
|
||||
if (group === 2)
|
||||
return (x | ~y) ^ z;
|
||||
if (group === 3)
|
||||
return (x & z) | (y & ~z);
|
||||
return x ^ (y | ~z);
|
||||
}
|
||||
// Reusable temporary buffer
|
||||
const BUF_160 = /* @__PURE__ */ new Uint32Array(16);
|
||||
class RIPEMD160 extends _md_ts_1.HashMD {
|
||||
constructor() {
|
||||
super(64, 20, 8, true);
|
||||
this.h0 = 0x67452301 | 0;
|
||||
this.h1 = 0xefcdab89 | 0;
|
||||
this.h2 = 0x98badcfe | 0;
|
||||
this.h3 = 0x10325476 | 0;
|
||||
this.h4 = 0xc3d2e1f0 | 0;
|
||||
}
|
||||
get() {
|
||||
const { h0, h1, h2, h3, h4 } = this;
|
||||
return [h0, h1, h2, h3, h4];
|
||||
}
|
||||
set(h0, h1, h2, h3, h4) {
|
||||
this.h0 = h0 | 0;
|
||||
this.h1 = h1 | 0;
|
||||
this.h2 = h2 | 0;
|
||||
this.h3 = h3 | 0;
|
||||
this.h4 = h4 | 0;
|
||||
}
|
||||
process(view, offset) {
|
||||
for (let i = 0; i < 16; i++, offset += 4)
|
||||
BUF_160[i] = view.getUint32(offset, true);
|
||||
// prettier-ignore
|
||||
let al = this.h0 | 0, ar = al, bl = this.h1 | 0, br = bl, cl = this.h2 | 0, cr = cl, dl = this.h3 | 0, dr = dl, el = this.h4 | 0, er = el;
|
||||
// Instead of iterating 0 to 80, we split it into 5 groups
|
||||
// And use the groups in constants, functions, etc. Much simpler
|
||||
for (let group = 0; group < 5; group++) {
|
||||
const rGroup = 4 - group;
|
||||
const hbl = Kl160[group], hbr = Kr160[group]; // prettier-ignore
|
||||
const rl = idxL[group], rr = idxR[group]; // prettier-ignore
|
||||
const sl = shiftsL160[group], sr = shiftsR160[group]; // prettier-ignore
|
||||
for (let i = 0; i < 16; i++) {
|
||||
const tl = ((0, utils_ts_1.rotl)(al + ripemd_f(group, bl, cl, dl) + BUF_160[rl[i]] + hbl, sl[i]) + el) | 0;
|
||||
al = el, el = dl, dl = (0, utils_ts_1.rotl)(cl, 10) | 0, cl = bl, bl = tl; // prettier-ignore
|
||||
}
|
||||
// 2 loops are 10% faster
|
||||
for (let i = 0; i < 16; i++) {
|
||||
const tr = ((0, utils_ts_1.rotl)(ar + ripemd_f(rGroup, br, cr, dr) + BUF_160[rr[i]] + hbr, sr[i]) + er) | 0;
|
||||
ar = er, er = dr, dr = (0, utils_ts_1.rotl)(cr, 10) | 0, cr = br, br = tr; // prettier-ignore
|
||||
}
|
||||
}
|
||||
// Add the compressed chunk to the current hash value
|
||||
this.set((this.h1 + cl + dr) | 0, (this.h2 + dl + er) | 0, (this.h3 + el + ar) | 0, (this.h4 + al + br) | 0, (this.h0 + bl + cr) | 0);
|
||||
}
|
||||
roundClean() {
|
||||
(0, utils_ts_1.clean)(BUF_160);
|
||||
}
|
||||
destroy() {
|
||||
this.destroyed = true;
|
||||
(0, utils_ts_1.clean)(this.buffer);
|
||||
this.set(0, 0, 0, 0, 0);
|
||||
}
|
||||
}
|
||||
exports.RIPEMD160 = RIPEMD160;
|
||||
/**
|
||||
* RIPEMD-160 - a legacy hash function from 1990s.
|
||||
* * https://homes.esat.kuleuven.be/~bosselae/ripemd160.html
|
||||
* * https://homes.esat.kuleuven.be/~bosselae/ripemd160/pdf/AB-9601/AB-9601.pdf
|
||||
*/
|
||||
exports.ripemd160 = (0, utils_ts_1.createHasher)(() => new RIPEMD160());
|
||||
//# sourceMappingURL=legacy.js.map
|
||||
@@ -0,0 +1,169 @@
|
||||
#define NAPI_VERSION 1
|
||||
#include <assert.h>
|
||||
#include <node_api.h>
|
||||
|
||||
napi_value Mask(napi_env env, napi_callback_info info) {
|
||||
napi_status status;
|
||||
size_t argc = 5;
|
||||
napi_value argv[5];
|
||||
|
||||
status = napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
|
||||
assert(status == napi_ok);
|
||||
|
||||
uint8_t *source;
|
||||
uint8_t *mask;
|
||||
uint8_t *destination;
|
||||
int64_t offset;
|
||||
int64_t length;
|
||||
|
||||
status = napi_get_buffer_info(env, argv[0], (void **)&source, NULL);
|
||||
assert(status == napi_ok);
|
||||
|
||||
status = napi_get_buffer_info(env, argv[1], (void **)&mask, NULL);
|
||||
assert(status == napi_ok);
|
||||
|
||||
status = napi_get_buffer_info(env, argv[2], (void **)&destination, NULL);
|
||||
assert(status == napi_ok);
|
||||
|
||||
status = napi_get_value_int64(env, argv[3], &offset);
|
||||
assert(status == napi_ok);
|
||||
|
||||
status = napi_get_value_int64(env, argv[4], &length);
|
||||
assert(status == napi_ok);
|
||||
|
||||
destination += offset;
|
||||
uint8_t index = 0;
|
||||
|
||||
//
|
||||
// Alignment preamble.
|
||||
//
|
||||
while (index < length && (size_t)source % 8) {
|
||||
*destination++ = *source++ ^ mask[index % 4];
|
||||
index++;
|
||||
}
|
||||
|
||||
length -= index;
|
||||
if (!length)
|
||||
return NULL;
|
||||
|
||||
//
|
||||
// Realign mask and convert to 64 bit.
|
||||
//
|
||||
uint8_t maskAlignedArray[8];
|
||||
|
||||
for (uint8_t i = 0; i < 8; i++, index++) {
|
||||
maskAlignedArray[i] = mask[index % 4];
|
||||
}
|
||||
|
||||
//
|
||||
// Apply 64 bit mask in 8 byte chunks.
|
||||
//
|
||||
int64_t loop = length / 8;
|
||||
uint64_t mask8 = ((uint64_t *)maskAlignedArray)[0];
|
||||
uint64_t *pFrom8 = (uint64_t *)source;
|
||||
uint64_t *pTo8 = (uint64_t *)destination;
|
||||
|
||||
for (int64_t i = 0; i < loop; i++) {
|
||||
pTo8[i] = pFrom8[i] ^ mask8;
|
||||
}
|
||||
|
||||
//
|
||||
// Apply mask to remaining data.
|
||||
//
|
||||
length %= 8;
|
||||
source += 8 * loop;
|
||||
destination += 8 * loop;
|
||||
|
||||
for (uint8_t i = 0; i < length; i++) {
|
||||
destination[i] = source[i] ^ maskAlignedArray[i];
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
napi_value Unmask(napi_env env, napi_callback_info info) {
|
||||
napi_status status;
|
||||
size_t argc = 2;
|
||||
napi_value argv[2];
|
||||
|
||||
status = napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
|
||||
assert(status == napi_ok);
|
||||
|
||||
uint8_t *source;
|
||||
uint8_t *mask;
|
||||
size_t length;
|
||||
|
||||
status = napi_get_buffer_info(env, argv[0], (void **)&source, &length);
|
||||
assert(status == napi_ok);
|
||||
|
||||
status = napi_get_buffer_info(env, argv[1], (void **)&mask, NULL);
|
||||
assert(status == napi_ok);
|
||||
|
||||
uint8_t index = 0;
|
||||
|
||||
//
|
||||
// Alignment preamble.
|
||||
//
|
||||
while (index < length && (size_t)source % 8) {
|
||||
*source++ ^= mask[index % 4];
|
||||
index++;
|
||||
}
|
||||
|
||||
length -= index;
|
||||
if (!length)
|
||||
return NULL;
|
||||
|
||||
//
|
||||
// Realign mask and convert to 64 bit.
|
||||
//
|
||||
uint8_t maskAlignedArray[8];
|
||||
|
||||
for (uint8_t i = 0; i < 8; i++, index++) {
|
||||
maskAlignedArray[i] = mask[index % 4];
|
||||
}
|
||||
|
||||
//
|
||||
// Apply 64 bit mask in 8 byte chunks.
|
||||
//
|
||||
size_t loop = length / 8;
|
||||
uint64_t mask8 = ((uint64_t *)maskAlignedArray)[0];
|
||||
uint64_t *pSource8 = (uint64_t *)source;
|
||||
|
||||
for (size_t i = 0; i < loop; i++) {
|
||||
pSource8[i] ^= mask8;
|
||||
}
|
||||
|
||||
//
|
||||
// Apply mask to remaining data.
|
||||
//
|
||||
length %= 8;
|
||||
source += 8 * loop;
|
||||
|
||||
for (uint8_t i = 0; i < length; i++) {
|
||||
source[i] ^= maskAlignedArray[i];
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
napi_value Init(napi_env env, napi_value exports) {
|
||||
napi_status status;
|
||||
napi_value mask;
|
||||
napi_value unmask;
|
||||
|
||||
status = napi_create_function(env, NULL, 0, Mask, NULL, &mask);
|
||||
assert(status == napi_ok);
|
||||
|
||||
status = napi_create_function(env, NULL, 0, Unmask, NULL, &unmask);
|
||||
assert(status == napi_ok);
|
||||
|
||||
status = napi_set_named_property(env, exports, "mask", mask);
|
||||
assert(status == napi_ok);
|
||||
|
||||
status = napi_set_named_property(env, exports, "unmask", unmask);
|
||||
assert(status == napi_ok);
|
||||
|
||||
return exports;
|
||||
}
|
||||
|
||||
NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)
|
||||
@@ -0,0 +1,313 @@
|
||||
import { a as ExternalFetchResult, c as ViteFetchResult, i as createWebSocketModuleRunnerTransport, n as ModuleRunnerTransportHandlers, o as FetchFunctionOptions, r as NormalizedModuleRunnerTransport, s as FetchResult, t as ModuleRunnerTransport } from "./chunks/moduleRunnerTransport.js";
|
||||
import { ModuleNamespace, ViteHotContext } from "#types/hot";
|
||||
import { HotPayload, Update } from "#types/hmrPayload";
|
||||
import { InferCustomEventPayload } from "#types/customEvent";
|
||||
//#region src/module-runner/sourcemap/decoder.d.ts
|
||||
interface SourceMapLike {
|
||||
version: number;
|
||||
mappings?: string;
|
||||
names?: string[];
|
||||
sources?: string[];
|
||||
sourcesContent?: string[];
|
||||
}
|
||||
declare class DecodedMap {
|
||||
map: SourceMapLike;
|
||||
_encoded: string;
|
||||
_decoded: undefined | number[][][];
|
||||
_decodedMemo: Stats;
|
||||
url: string;
|
||||
file: string;
|
||||
version: number;
|
||||
names: string[];
|
||||
resolvedSources: string[];
|
||||
constructor(map: SourceMapLike, from: string);
|
||||
}
|
||||
interface Stats {
|
||||
lastKey: number;
|
||||
lastNeedle: number;
|
||||
lastIndex: number;
|
||||
}
|
||||
//#endregion
|
||||
//#region src/shared/hmr.d.ts
|
||||
type CustomListenersMap = Map<string, ((data: any) => void)[]>;
|
||||
interface HotModule {
|
||||
id: string;
|
||||
callbacks: HotCallback[];
|
||||
}
|
||||
interface HotCallback {
|
||||
deps: string[];
|
||||
fn: (modules: Array<ModuleNamespace | undefined>) => void;
|
||||
}
|
||||
interface HMRLogger {
|
||||
error(msg: string | Error): void;
|
||||
debug(...msg: unknown[]): void;
|
||||
}
|
||||
declare class HMRClient {
|
||||
logger: HMRLogger;
|
||||
private transport;
|
||||
private importUpdatedModule;
|
||||
hotModulesMap: Map<string, HotModule>;
|
||||
disposeMap: Map<string, (data: any) => void | Promise<void>>;
|
||||
pruneMap: Map<string, (data: any) => void | Promise<void>>;
|
||||
dataMap: Map<string, any>;
|
||||
customListenersMap: CustomListenersMap;
|
||||
ctxToListenersMap: Map<string, CustomListenersMap>;
|
||||
currentFirstInvalidatedBy: string | undefined;
|
||||
constructor(logger: HMRLogger, transport: NormalizedModuleRunnerTransport, importUpdatedModule: (update: Update) => Promise<ModuleNamespace>);
|
||||
notifyListeners<T extends string>(event: T, data: InferCustomEventPayload<T>): Promise<void>;
|
||||
send(payload: HotPayload): void;
|
||||
clear(): void;
|
||||
prunePaths(paths: string[]): Promise<void>;
|
||||
protected warnFailedUpdate(err: Error, path: string | string[]): void;
|
||||
private updateQueue;
|
||||
private pendingUpdateQueue;
|
||||
/**
|
||||
* buffer multiple hot updates triggered by the same src change
|
||||
* so that they are invoked in the same order they were sent.
|
||||
* (otherwise the order may be inconsistent because of the http request round trip)
|
||||
*/
|
||||
queueUpdate(payload: Update): Promise<void>;
|
||||
private fetchUpdate;
|
||||
}
|
||||
//#endregion
|
||||
//#region src/shared/ssrTransform.d.ts
|
||||
interface DefineImportMetadata {
|
||||
/**
|
||||
* Imported names before being transformed to `ssrImportKey`
|
||||
*
|
||||
* import foo, { bar as baz, qux } from 'hello'
|
||||
* => ['default', 'bar', 'qux']
|
||||
*
|
||||
* import * as namespace from 'world
|
||||
* => undefined
|
||||
*/
|
||||
importedNames?: string[];
|
||||
}
|
||||
interface SSRImportMetadata extends DefineImportMetadata {
|
||||
isDynamicImport?: boolean;
|
||||
}
|
||||
//#endregion
|
||||
//#region src/module-runner/constants.d.ts
|
||||
declare const ssrModuleExportsKey = "__vite_ssr_exports__";
|
||||
declare const ssrImportKey = "__vite_ssr_import__";
|
||||
declare const ssrDynamicImportKey = "__vite_ssr_dynamic_import__";
|
||||
declare const ssrExportAllKey = "__vite_ssr_exportAll__";
|
||||
declare const ssrExportNameKey = "__vite_ssr_exportName__";
|
||||
declare const ssrImportMetaKey = "__vite_ssr_import_meta__";
|
||||
//#endregion
|
||||
//#region src/module-runner/runner.d.ts
|
||||
interface ModuleRunnerDebugger {
|
||||
(formatter: unknown, ...args: unknown[]): void;
|
||||
}
|
||||
declare class ModuleRunner {
|
||||
options: ModuleRunnerOptions;
|
||||
evaluator: ModuleEvaluator;
|
||||
private debug?;
|
||||
evaluatedModules: EvaluatedModules;
|
||||
hmrClient?: HMRClient;
|
||||
private readonly transport;
|
||||
private readonly resetSourceMapSupport?;
|
||||
private readonly concurrentModuleNodePromises;
|
||||
private isBuiltin?;
|
||||
private builtinsPromise?;
|
||||
private closed;
|
||||
constructor(options: ModuleRunnerOptions, evaluator?: ModuleEvaluator, debug?: ModuleRunnerDebugger | undefined);
|
||||
/**
|
||||
* URL to execute. Accepts file path, server path or id relative to the root.
|
||||
*/
|
||||
import<T = any>(url: string): Promise<T>;
|
||||
/**
|
||||
* Clear all caches including HMR listeners.
|
||||
*/
|
||||
clearCache(): void;
|
||||
/**
|
||||
* Clears all caches, removes all HMR listeners, and resets source map support.
|
||||
* This method doesn't stop the HMR connection.
|
||||
*/
|
||||
close(): Promise<void>;
|
||||
/**
|
||||
* Returns `true` if the runtime has been closed by calling `close()` method.
|
||||
*/
|
||||
isClosed(): boolean;
|
||||
private processImport;
|
||||
private isCircularRequest;
|
||||
private cachedRequest;
|
||||
private cachedModule;
|
||||
private ensureBuiltins;
|
||||
private getModuleInformation;
|
||||
protected directRequest(url: string, mod: EvaluatedModuleNode, _callstack: string[]): Promise<any>;
|
||||
}
|
||||
//#endregion
|
||||
//#region src/module-runner/sourcemap/interceptor.d.ts
|
||||
interface RetrieveFileHandler {
|
||||
(path: string): string | null | undefined | false;
|
||||
}
|
||||
interface RetrieveSourceMapHandler {
|
||||
(path: string): null | {
|
||||
url: string;
|
||||
map: any;
|
||||
};
|
||||
}
|
||||
interface InterceptorOptions {
|
||||
retrieveFile?: RetrieveFileHandler;
|
||||
retrieveSourceMap?: RetrieveSourceMapHandler;
|
||||
}
|
||||
//#endregion
|
||||
//#region src/module-runner/types.d.ts
|
||||
interface ModuleRunnerImportMeta {
|
||||
url: string;
|
||||
env: ImportMetaEnv;
|
||||
hot?: ViteHotContext;
|
||||
dirname: string;
|
||||
filename: string;
|
||||
glob: (...args: any[]) => any;
|
||||
resolve(specifier: string, parent?: string): string;
|
||||
[key: string]: any;
|
||||
}
|
||||
interface ModuleRunnerContext {
|
||||
[ssrModuleExportsKey]: Record<string, any>;
|
||||
[ssrImportKey]: (id: string, metadata?: DefineImportMetadata) => Promise<any>;
|
||||
[ssrDynamicImportKey]: (id: string, options?: ImportCallOptions) => Promise<any>;
|
||||
[ssrExportAllKey]: (obj: any) => void;
|
||||
[ssrExportNameKey]: (name: string, getter: () => unknown) => void;
|
||||
[ssrImportMetaKey]: ModuleRunnerImportMeta;
|
||||
}
|
||||
interface ModuleEvaluator {
|
||||
/**
|
||||
* Number of prefixed lines in the transformed code.
|
||||
*/
|
||||
startOffset?: number;
|
||||
/**
|
||||
* Run code that was transformed by Vite.
|
||||
* @param context Function context
|
||||
* @param code Transformed code
|
||||
* @param module The module node
|
||||
*/
|
||||
runInlinedModule(context: ModuleRunnerContext, code: string, module: Readonly<EvaluatedModuleNode>): Promise<any>;
|
||||
/**
|
||||
* Run externalized module.
|
||||
* @param file File URL to the external module
|
||||
*/
|
||||
runExternalModule(file: string): Promise<any>;
|
||||
}
|
||||
type ResolvedResult = (ExternalFetchResult | ViteFetchResult) & {
|
||||
url: string;
|
||||
id: string;
|
||||
};
|
||||
type FetchFunction = (id: string, importer?: string, options?: FetchFunctionOptions) => Promise<FetchResult>;
|
||||
interface ModuleRunnerHmr {
|
||||
/**
|
||||
* Configure HMR logger.
|
||||
*/
|
||||
logger?: false | HMRLogger;
|
||||
}
|
||||
interface ModuleRunnerOptions {
|
||||
/**
|
||||
* A set of methods to communicate with the server.
|
||||
*/
|
||||
transport: ModuleRunnerTransport;
|
||||
/**
|
||||
* Configure how source maps are resolved. Prefers `node` if `process.setSourceMapsEnabled` is available.
|
||||
* Otherwise it will use `prepareStackTrace` by default which overrides `Error.prepareStackTrace` method.
|
||||
* You can provide an object to configure how file contents and source maps are resolved for files that were not processed by Vite.
|
||||
*/
|
||||
sourcemapInterceptor?: false | "node" | "prepareStackTrace" | InterceptorOptions;
|
||||
/**
|
||||
* Disable HMR or configure HMR options.
|
||||
*
|
||||
* @default true
|
||||
*/
|
||||
hmr?: boolean | ModuleRunnerHmr;
|
||||
/**
|
||||
* Create import.meta object for the module.
|
||||
*
|
||||
* @default createDefaultImportMeta
|
||||
*/
|
||||
createImportMeta?: (modulePath: string) => ModuleRunnerImportMeta | Promise<ModuleRunnerImportMeta>;
|
||||
/**
|
||||
* Custom module cache. If not provided, creates a separate module cache for each ModuleRunner instance.
|
||||
*/
|
||||
evaluatedModules?: EvaluatedModules;
|
||||
}
|
||||
interface ImportMetaEnv {
|
||||
[key: string]: any;
|
||||
BASE_URL: string;
|
||||
MODE: string;
|
||||
DEV: boolean;
|
||||
PROD: boolean;
|
||||
SSR: boolean;
|
||||
}
|
||||
//#endregion
|
||||
//#region src/module-runner/evaluatedModules.d.ts
|
||||
declare class EvaluatedModuleNode {
|
||||
id: string;
|
||||
url: string;
|
||||
importers: Set<string>;
|
||||
imports: Set<string>;
|
||||
evaluated: boolean;
|
||||
meta: ResolvedResult | undefined;
|
||||
promise: Promise<any> | undefined;
|
||||
exports: any;
|
||||
file: string;
|
||||
map: DecodedMap | undefined;
|
||||
constructor(id: string, url: string);
|
||||
}
|
||||
declare class EvaluatedModules {
|
||||
readonly idToModuleMap: Map<string, EvaluatedModuleNode>;
|
||||
readonly fileToModulesMap: Map<string, Set<EvaluatedModuleNode>>;
|
||||
readonly urlToIdModuleMap: Map<string, EvaluatedModuleNode>;
|
||||
/**
|
||||
* Returns the module node by the resolved module ID. Usually, module ID is
|
||||
* the file system path with query and/or hash. It can also be a virtual module.
|
||||
*
|
||||
* Module runner graph will have 1 to 1 mapping with the server module graph.
|
||||
* @param id Resolved module ID
|
||||
*/
|
||||
getModuleById(id: string): EvaluatedModuleNode | undefined;
|
||||
/**
|
||||
* Returns all modules related to the file system path. Different modules
|
||||
* might have different query parameters or hash, so it's possible to have
|
||||
* multiple modules for the same file.
|
||||
* @param file The file system path of the module
|
||||
*/
|
||||
getModulesByFile(file: string): Set<EvaluatedModuleNode> | undefined;
|
||||
/**
|
||||
* Returns the module node by the URL that was used in the import statement.
|
||||
* Unlike module graph on the server, the URL is not resolved and is used as is.
|
||||
* @param url Server URL that was used in the import statement
|
||||
*/
|
||||
getModuleByUrl(url: string): EvaluatedModuleNode | undefined;
|
||||
/**
|
||||
* Ensure that module is in the graph. If the module is already in the graph,
|
||||
* it will return the existing module node. Otherwise, it will create a new
|
||||
* module node and add it to the graph.
|
||||
* @param id Resolved module ID
|
||||
* @param url URL that was used in the import statement
|
||||
*/
|
||||
ensureModule(id: string, url: string): EvaluatedModuleNode;
|
||||
invalidateModule(node: EvaluatedModuleNode): void;
|
||||
/**
|
||||
* Extracts the inlined source map from the module code and returns the decoded
|
||||
* source map. If the source map is not inlined, it will return null.
|
||||
* @param id Resolved module ID
|
||||
*/
|
||||
getModuleSourceMapById(id: string): DecodedMap | null;
|
||||
clear(): void;
|
||||
}
|
||||
declare function normalizeModuleId(file: string): string;
|
||||
//#endregion
|
||||
//#region src/module-runner/esmEvaluator.d.ts
|
||||
declare class ESModulesEvaluator implements ModuleEvaluator {
|
||||
readonly startOffset: number;
|
||||
runInlinedModule(context: ModuleRunnerContext, code: string): Promise<any>;
|
||||
runExternalModule(filepath: string): Promise<any>;
|
||||
}
|
||||
//#endregion
|
||||
//#region src/module-runner/createImportMeta.d.ts
|
||||
declare function createDefaultImportMeta(modulePath: string): ModuleRunnerImportMeta;
|
||||
/**
|
||||
* Create import.meta object for Node.js.
|
||||
*/
|
||||
declare function createNodeImportMeta(modulePath: string): ModuleRunnerImportMeta;
|
||||
//#endregion
|
||||
export { ESModulesEvaluator, type EvaluatedModuleNode, EvaluatedModules, type FetchFunction, type FetchFunctionOptions, type FetchResult, type HMRLogger, type InterceptorOptions, type ModuleEvaluator, ModuleRunner, type ModuleRunnerContext, type ModuleRunnerHmr, type ModuleRunnerImportMeta, type ModuleRunnerOptions, type ModuleRunnerTransport, type ModuleRunnerTransportHandlers, type ResolvedResult, type SSRImportMetadata, createDefaultImportMeta, createNodeImportMeta, createWebSocketModuleRunnerTransport, normalizeModuleId, ssrDynamicImportKey, ssrExportAllKey, ssrExportNameKey, ssrImportKey, ssrImportMetaKey, ssrModuleExportsKey };
|
||||
@@ -0,0 +1,121 @@
|
||||
/* -*- 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
|
||||
*/
|
||||
|
||||
var util = require('./util');
|
||||
var has = Object.prototype.hasOwnProperty;
|
||||
var hasNativeMap = typeof Map !== "undefined";
|
||||
|
||||
/**
|
||||
* A data structure which is a combination of an array and a set. Adding a new
|
||||
* member is O(1), testing for membership is O(1), and finding the index of an
|
||||
* element is O(1). Removing elements from the set is not supported. Only
|
||||
* strings are supported for membership.
|
||||
*/
|
||||
function ArraySet() {
|
||||
this._array = [];
|
||||
this._set = hasNativeMap ? new Map() : Object.create(null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Static method for creating ArraySet instances from an existing array.
|
||||
*/
|
||||
ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
|
||||
var set = new ArraySet();
|
||||
for (var i = 0, len = aArray.length; i < len; i++) {
|
||||
set.add(aArray[i], aAllowDuplicates);
|
||||
}
|
||||
return set;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return how many unique items are in this ArraySet. If duplicates have been
|
||||
* added, than those do not count towards the size.
|
||||
*
|
||||
* @returns Number
|
||||
*/
|
||||
ArraySet.prototype.size = function ArraySet_size() {
|
||||
return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;
|
||||
};
|
||||
|
||||
/**
|
||||
* Add the given string to this set.
|
||||
*
|
||||
* @param String aStr
|
||||
*/
|
||||
ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
|
||||
var sStr = hasNativeMap ? aStr : util.toSetString(aStr);
|
||||
var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);
|
||||
var idx = this._array.length;
|
||||
if (!isDuplicate || aAllowDuplicates) {
|
||||
this._array.push(aStr);
|
||||
}
|
||||
if (!isDuplicate) {
|
||||
if (hasNativeMap) {
|
||||
this._set.set(aStr, idx);
|
||||
} else {
|
||||
this._set[sStr] = idx;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Is the given string a member of this set?
|
||||
*
|
||||
* @param String aStr
|
||||
*/
|
||||
ArraySet.prototype.has = function ArraySet_has(aStr) {
|
||||
if (hasNativeMap) {
|
||||
return this._set.has(aStr);
|
||||
} else {
|
||||
var sStr = util.toSetString(aStr);
|
||||
return has.call(this._set, sStr);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* What is the index of the given string in the array?
|
||||
*
|
||||
* @param String aStr
|
||||
*/
|
||||
ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
|
||||
if (hasNativeMap) {
|
||||
var idx = this._set.get(aStr);
|
||||
if (idx >= 0) {
|
||||
return idx;
|
||||
}
|
||||
} else {
|
||||
var sStr = util.toSetString(aStr);
|
||||
if (has.call(this._set, sStr)) {
|
||||
return this._set[sStr];
|
||||
}
|
||||
}
|
||||
|
||||
throw new Error('"' + aStr + '" is not in the set.');
|
||||
};
|
||||
|
||||
/**
|
||||
* What is the element at the given index?
|
||||
*
|
||||
* @param Number aIdx
|
||||
*/
|
||||
ArraySet.prototype.at = function ArraySet_at(aIdx) {
|
||||
if (aIdx >= 0 && aIdx < this._array.length) {
|
||||
return this._array[aIdx];
|
||||
}
|
||||
throw new Error('No element indexed by ' + aIdx);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the array representation of this set (which has the proper indices
|
||||
* indicated by indexOf). Note that this is a copy of the internal array used
|
||||
* for storing the members so that no one can mess with internal state.
|
||||
*/
|
||||
ArraySet.prototype.toArray = function ArraySet_toArray() {
|
||||
return this._array.slice();
|
||||
};
|
||||
|
||||
exports.ArraySet = ArraySet;
|
||||
@@ -0,0 +1,89 @@
|
||||
{
|
||||
"name": "nanoid",
|
||||
"version": "3.3.18",
|
||||
"description": "A tiny (116 bytes), secure URL-friendly unique string ID generator",
|
||||
"keywords": [
|
||||
"uuid",
|
||||
"random",
|
||||
"id",
|
||||
"url"
|
||||
],
|
||||
"engines": {
|
||||
"node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
|
||||
},
|
||||
"funding": [
|
||||
{
|
||||
"type": "github",
|
||||
"url": "https://github.com/sponsors/ai"
|
||||
}
|
||||
],
|
||||
"author": "Andrey Sitnik <andrey@sitnik.ru>",
|
||||
"license": "MIT",
|
||||
"repository": "ai/nanoid",
|
||||
"browser": {
|
||||
"./index.js": "./index.browser.js",
|
||||
"./async/index.js": "./async/index.browser.js",
|
||||
"./async/index.cjs": "./async/index.browser.cjs",
|
||||
"./index.cjs": "./index.browser.cjs"
|
||||
},
|
||||
"react-native": "index.js",
|
||||
"bin": "./bin/nanoid.cjs",
|
||||
"sideEffects": false,
|
||||
"types": "./index.d.ts",
|
||||
"type": "module",
|
||||
"main": "index.cjs",
|
||||
"module": "index.js",
|
||||
"exports": {
|
||||
".": {
|
||||
"react-native": "./index.browser.js",
|
||||
"browser": "./index.browser.js",
|
||||
"require": {
|
||||
"types": "./index.d.cts",
|
||||
"default": "./index.cjs"
|
||||
},
|
||||
"import": {
|
||||
"types": "./index.d.ts",
|
||||
"default": "./index.js"
|
||||
},
|
||||
"default": "./index.js"
|
||||
},
|
||||
"./package.json": "./package.json",
|
||||
"./async/package.json": "./async/package.json",
|
||||
"./async": {
|
||||
"browser": "./async/index.browser.js",
|
||||
"require": {
|
||||
"types": "./index.d.cts",
|
||||
"default": "./async/index.cjs"
|
||||
},
|
||||
"import": {
|
||||
"types": "./index.d.ts",
|
||||
"default": "./async/index.js"
|
||||
},
|
||||
"default": "./async/index.js"
|
||||
},
|
||||
"./non-secure/package.json": "./non-secure/package.json",
|
||||
"./non-secure": {
|
||||
"require": {
|
||||
"types": "./index.d.cts",
|
||||
"default": "./non-secure/index.cjs"
|
||||
},
|
||||
"import": {
|
||||
"types": "./index.d.ts",
|
||||
"default": "./non-secure/index.js"
|
||||
},
|
||||
"default": "./non-secure/index.js"
|
||||
},
|
||||
"./url-alphabet/package.json": "./url-alphabet/package.json",
|
||||
"./url-alphabet": {
|
||||
"require": {
|
||||
"types": "./index.d.cts",
|
||||
"default": "./url-alphabet/index.cjs"
|
||||
},
|
||||
"import": {
|
||||
"types": "./index.d.ts",
|
||||
"default": "./url-alphabet/index.js"
|
||||
},
|
||||
"default": "./url-alphabet/index.js"
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,146 @@
|
||||
'use strict';
|
||||
|
||||
var IDENTIFIER = /^[a-z_$][a-z0-9_$-]*$/i;
|
||||
var customRuleCode = require('./dotjs/custom');
|
||||
var definitionSchema = require('./definition_schema');
|
||||
|
||||
module.exports = {
|
||||
add: addKeyword,
|
||||
get: getKeyword,
|
||||
remove: removeKeyword,
|
||||
validate: validateKeyword
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Define custom keyword
|
||||
* @this Ajv
|
||||
* @param {String} keyword custom keyword, should be unique (including different from all standard, custom and macro keywords).
|
||||
* @param {Object} definition keyword definition object with properties `type` (type(s) which the keyword applies to), `validate` or `compile`.
|
||||
* @return {Ajv} this for method chaining
|
||||
*/
|
||||
function addKeyword(keyword, definition) {
|
||||
/* jshint validthis: true */
|
||||
/* eslint no-shadow: 0 */
|
||||
var RULES = this.RULES;
|
||||
if (RULES.keywords[keyword])
|
||||
throw new Error('Keyword ' + keyword + ' is already defined');
|
||||
|
||||
if (!IDENTIFIER.test(keyword))
|
||||
throw new Error('Keyword ' + keyword + ' is not a valid identifier');
|
||||
|
||||
if (definition) {
|
||||
this.validateKeyword(definition, true);
|
||||
|
||||
var dataType = definition.type;
|
||||
if (Array.isArray(dataType)) {
|
||||
for (var i=0; i<dataType.length; i++)
|
||||
_addRule(keyword, dataType[i], definition);
|
||||
} else {
|
||||
_addRule(keyword, dataType, definition);
|
||||
}
|
||||
|
||||
var metaSchema = definition.metaSchema;
|
||||
if (metaSchema) {
|
||||
if (definition.$data && this._opts.$data) {
|
||||
metaSchema = {
|
||||
anyOf: [
|
||||
metaSchema,
|
||||
{ '$ref': 'https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#' }
|
||||
]
|
||||
};
|
||||
}
|
||||
definition.validateSchema = this.compile(metaSchema, true);
|
||||
}
|
||||
}
|
||||
|
||||
RULES.keywords[keyword] = RULES.all[keyword] = true;
|
||||
|
||||
|
||||
function _addRule(keyword, dataType, definition) {
|
||||
var ruleGroup;
|
||||
for (var i=0; i<RULES.length; i++) {
|
||||
var rg = RULES[i];
|
||||
if (rg.type == dataType) {
|
||||
ruleGroup = rg;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!ruleGroup) {
|
||||
ruleGroup = { type: dataType, rules: [] };
|
||||
RULES.push(ruleGroup);
|
||||
}
|
||||
|
||||
var rule = {
|
||||
keyword: keyword,
|
||||
definition: definition,
|
||||
custom: true,
|
||||
code: customRuleCode,
|
||||
implements: definition.implements
|
||||
};
|
||||
ruleGroup.rules.push(rule);
|
||||
RULES.custom[keyword] = rule;
|
||||
}
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Get keyword
|
||||
* @this Ajv
|
||||
* @param {String} keyword pre-defined or custom keyword.
|
||||
* @return {Object|Boolean} custom keyword definition, `true` if it is a predefined keyword, `false` otherwise.
|
||||
*/
|
||||
function getKeyword(keyword) {
|
||||
/* jshint validthis: true */
|
||||
var rule = this.RULES.custom[keyword];
|
||||
return rule ? rule.definition : this.RULES.keywords[keyword] || false;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Remove keyword
|
||||
* @this Ajv
|
||||
* @param {String} keyword pre-defined or custom keyword.
|
||||
* @return {Ajv} this for method chaining
|
||||
*/
|
||||
function removeKeyword(keyword) {
|
||||
/* jshint validthis: true */
|
||||
var RULES = this.RULES;
|
||||
delete RULES.keywords[keyword];
|
||||
delete RULES.all[keyword];
|
||||
delete RULES.custom[keyword];
|
||||
for (var i=0; i<RULES.length; i++) {
|
||||
var rules = RULES[i].rules;
|
||||
for (var j=0; j<rules.length; j++) {
|
||||
if (rules[j].keyword == keyword) {
|
||||
rules.splice(j, 1);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Validate keyword definition
|
||||
* @this Ajv
|
||||
* @param {Object} definition keyword definition object.
|
||||
* @param {Boolean} throwError true to throw exception if definition is invalid
|
||||
* @return {boolean} validation result
|
||||
*/
|
||||
function validateKeyword(definition, throwError) {
|
||||
validateKeyword.errors = null;
|
||||
var v = this._validateKeyword = this._validateKeyword
|
||||
|| this.compile(definitionSchema, true);
|
||||
|
||||
if (v(definition)) return true;
|
||||
validateKeyword.errors = v.errors;
|
||||
if (throwError)
|
||||
throw new Error('custom keyword definition is invalid: ' + this.errorsText(v.errors));
|
||||
else
|
||||
return false;
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
language: node_js
|
||||
node_js:
|
||||
- '0.10'
|
||||
@@ -0,0 +1,8 @@
|
||||
import { join } from 'node:path'
|
||||
import pino from '../../..'
|
||||
|
||||
const transport = pino.transport({
|
||||
target: join(__dirname, 'transport-worker.ts')
|
||||
})
|
||||
const logger = pino(transport)
|
||||
logger.info('Hello')
|
||||
@@ -0,0 +1,113 @@
|
||||
#!/usr/bin/env node
|
||||
|
||||
'use strict'
|
||||
|
||||
const fs = require('node:fs')
|
||||
const path = require('node:path')
|
||||
const help = require('help-me')({
|
||||
dir: path.join(__dirname, 'help'),
|
||||
ext: '.txt'
|
||||
})
|
||||
const pump = require('pump')
|
||||
const sjp = require('secure-json-parse')
|
||||
const JoyCon = require('joycon')
|
||||
const { default: stripJsonComments } = require('strip-json-comments')
|
||||
|
||||
const build = require('./')
|
||||
const CONSTANTS = require('./lib/constants')
|
||||
const { isObject } = require('./lib/utils')
|
||||
const minimist = require('minimist')
|
||||
|
||||
const parseJSON = input => {
|
||||
return sjp.parse(stripJsonComments(input), { protoAction: 'remove' })
|
||||
}
|
||||
|
||||
const joycon = new JoyCon({
|
||||
parseJSON,
|
||||
files: [
|
||||
'pino-pretty.config.cjs',
|
||||
'pino-pretty.config.js',
|
||||
'.pino-prettyrc',
|
||||
'.pino-prettyrc.json'
|
||||
],
|
||||
stopDir: path.dirname(process.cwd())
|
||||
})
|
||||
|
||||
const cmd = minimist(process.argv.slice(2))
|
||||
|
||||
if (cmd.h || cmd.help) {
|
||||
help.toStdout()
|
||||
} else {
|
||||
const DEFAULT_VALUE = '\0default'
|
||||
|
||||
let opts = minimist(process.argv, {
|
||||
alias: {
|
||||
colorize: 'c',
|
||||
crlf: 'f',
|
||||
errorProps: 'e',
|
||||
levelFirst: 'l',
|
||||
minimumLevel: 'L',
|
||||
customLevels: 'x',
|
||||
customColors: 'X',
|
||||
useOnlyCustomProps: 'U',
|
||||
errorLikeObjectKeys: 'k',
|
||||
messageKey: 'm',
|
||||
levelKey: CONSTANTS.LEVEL_KEY,
|
||||
levelLabel: 'b',
|
||||
messageFormat: 'o',
|
||||
timestampKey: 'a',
|
||||
translateTime: 't',
|
||||
ignore: 'i',
|
||||
include: 'I',
|
||||
hideObject: 'H',
|
||||
singleLine: 'S'
|
||||
},
|
||||
default: {
|
||||
messageKey: DEFAULT_VALUE,
|
||||
minimumLevel: DEFAULT_VALUE,
|
||||
levelKey: DEFAULT_VALUE,
|
||||
timestampKey: DEFAULT_VALUE
|
||||
}
|
||||
})
|
||||
|
||||
// Remove default values
|
||||
opts = filter(opts, value => value !== DEFAULT_VALUE)
|
||||
const config = loadConfig(opts.config)
|
||||
// Override config with cli options
|
||||
opts = Object.assign({}, config, opts)
|
||||
// set defaults
|
||||
opts.errorLikeObjectKeys = opts.errorLikeObjectKeys || 'err,error'
|
||||
opts.errorProps = opts.errorProps || ''
|
||||
|
||||
const res = build(opts)
|
||||
pump(process.stdin, res)
|
||||
|
||||
// https://github.com/pinojs/pino/pull/358
|
||||
/* istanbul ignore next */
|
||||
if (!process.stdin.isTTY && !fs.fstatSync(process.stdin.fd).isFile()) {
|
||||
process.once('SIGINT', function noOp () {})
|
||||
}
|
||||
|
||||
function loadConfig (configPath) {
|
||||
const files = configPath ? [path.resolve(configPath)] : undefined
|
||||
const result = joycon.loadSync(files)
|
||||
if (result.path && !isObject(result.data)) {
|
||||
configPath = configPath || path.basename(result.path)
|
||||
throw new Error(`Invalid runtime configuration file: ${configPath}`)
|
||||
}
|
||||
if (configPath && !result.data) {
|
||||
throw new Error(`Failed to load runtime configuration file: ${configPath}`)
|
||||
}
|
||||
return result.data
|
||||
}
|
||||
|
||||
function filter (obj, cb) {
|
||||
return Object.keys(obj).reduce((acc, key) => {
|
||||
const value = obj[key]
|
||||
if (cb(value, key)) {
|
||||
acc[key] = value
|
||||
}
|
||||
return acc
|
||||
}, {})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
/*! *****************************************************************************
|
||||
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" />
|
||||
/// <reference lib="es2016.array.include" />
|
||||
/// <reference lib="es2016.intl" />
|
||||
Reference in New Issue
Block a user