diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/acorn-walk/dist/walk.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/acorn-walk/dist/walk.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..e07a6afaf8e336137fe00b1321f6de3b7f0085ea --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/acorn-walk/dist/walk.d.mts @@ -0,0 +1,177 @@ +import * as acorn from "acorn" + +export type FullWalkerCallback = ( + node: acorn.Node, + state: TState, + type: string +) => void + +export type FullAncestorWalkerCallback = ( + node: acorn.Node, + state: TState, + ancestors: acorn.Node[], + type: string +) => void + +type AggregateType = { + Expression: acorn.Expression, + Statement: acorn.Statement, + Function: acorn.Function, + Class: acorn.Class, + Pattern: acorn.Pattern, + ForInit: acorn.VariableDeclaration | acorn.Expression +} + +export type SimpleVisitors = { + [type in acorn.AnyNode["type"]]?: (node: Extract, state: TState) => void +} & { + [type in keyof AggregateType]?: (node: AggregateType[type], state: TState) => void +} + +export type AncestorVisitors = { + [type in acorn.AnyNode["type"]]?: ( node: Extract, state: TState, ancestors: acorn.Node[] +) => void +} & { + [type in keyof AggregateType]?: (node: AggregateType[type], state: TState, ancestors: acorn.Node[]) => void +} + +export type WalkerCallback = (node: acorn.Node, state: TState) => void + +export type RecursiveVisitors = { + [type in acorn.AnyNode["type"]]?: ( node: Extract, state: TState, callback: WalkerCallback) => void +} & { + [type in keyof AggregateType]?: (node: AggregateType[type], state: TState, callback: WalkerCallback) => void +} + +export type FindPredicate = (type: string, node: acorn.Node) => boolean + +export interface Found { + node: acorn.Node, + state: TState +} + +/** + * does a 'simple' walk over a tree + * @param node the AST node to walk + * @param visitors an object with properties whose names correspond to node types in the {@link https://github.com/estree/estree | ESTree spec}. The properties should contain functions that will be called with the node object and, if applicable the state at that point. + * @param base a walker algorithm + * @param state a start state. The default walker will simply visit all statements and expressions and not produce a meaningful state. (An example of a use of state is to track scope at each point in the tree.) + */ +export function simple( + node: acorn.Node, + visitors: SimpleVisitors, + base?: RecursiveVisitors, + state?: TState +): void + +/** + * does a 'simple' walk over a tree, building up an array of ancestor nodes (including the current node) and passing the array to the callbacks as a third parameter. + * @param node + * @param visitors + * @param base + * @param state + */ +export function ancestor( + node: acorn.Node, + visitors: AncestorVisitors, + base?: RecursiveVisitors, + state?: TState + ): void + +/** + * does a 'recursive' walk, where the walker functions are responsible for continuing the walk on the child nodes of their target node. + * @param node + * @param state the start state + * @param functions contain an object that maps node types to walker functions + * @param base provides the fallback walker functions for node types that aren't handled in the {@link functions} object. If not given, the default walkers will be used. + */ +export function recursive( + node: acorn.Node, + state: TState, + functions: RecursiveVisitors, + base?: RecursiveVisitors +): void + +/** + * does a 'full' walk over a tree, calling the {@link callback} with the arguments (node, state, type) for each node + * @param node + * @param callback + * @param base + * @param state + */ +export function full( + node: acorn.Node, + callback: FullWalkerCallback, + base?: RecursiveVisitors, + state?: TState +): void + +/** + * does a 'full' walk over a tree, building up an array of ancestor nodes (including the current node) and passing the array to the callbacks as a third parameter. + * @param node + * @param callback + * @param base + * @param state + */ +export function fullAncestor( + node: acorn.Node, + callback: FullAncestorWalkerCallback, + base?: RecursiveVisitors, + state?: TState +): void + +/** + * builds a new walker object by using the walker functions in {@link functions} and filling in the missing ones by taking defaults from {@link base}. + * @param functions + * @param base + */ +export function make( + functions: RecursiveVisitors, + base?: RecursiveVisitors +): RecursiveVisitors + +/** + * tries to locate a node in a tree at the given start and/or end offsets, which satisfies the predicate test. {@link start} and {@link end} can be either `null` (as wildcard) or a `number`. {@link test} may be a string (indicating a node type) or a function that takes (nodeType, node) arguments and returns a boolean indicating whether this node is interesting. {@link base} and {@link state} are optional, and can be used to specify a custom walker. Nodes are tested from inner to outer, so if two nodes match the boundaries, the inner one will be preferred. + * @param node + * @param start + * @param end + * @param type + * @param base + * @param state + */ +export function findNodeAt( + node: acorn.Node, + start: number | undefined, + end?: number | undefined, + type?: FindPredicate | string, + base?: RecursiveVisitors, + state?: TState +): Found | undefined + +/** + * like {@link findNodeAt}, but will match any node that exists 'around' (spanning) the given position. + * @param node + * @param start + * @param type + * @param base + * @param state + */ +export function findNodeAround( + node: acorn.Node, + start: number | undefined, + type?: FindPredicate | string, + base?: RecursiveVisitors, + state?: TState +): Found | undefined + +/** + * Find the outermost matching node after a given position. + */ +export const findNodeAfter: typeof findNodeAround + +/** + * Find the outermost matching node before a given position. + */ +export const findNodeBefore: typeof findNodeAround + +export const base: RecursiveVisitors diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/acorn-walk/dist/walk.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/acorn-walk/dist/walk.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e07a6afaf8e336137fe00b1321f6de3b7f0085ea --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/acorn-walk/dist/walk.d.ts @@ -0,0 +1,177 @@ +import * as acorn from "acorn" + +export type FullWalkerCallback = ( + node: acorn.Node, + state: TState, + type: string +) => void + +export type FullAncestorWalkerCallback = ( + node: acorn.Node, + state: TState, + ancestors: acorn.Node[], + type: string +) => void + +type AggregateType = { + Expression: acorn.Expression, + Statement: acorn.Statement, + Function: acorn.Function, + Class: acorn.Class, + Pattern: acorn.Pattern, + ForInit: acorn.VariableDeclaration | acorn.Expression +} + +export type SimpleVisitors = { + [type in acorn.AnyNode["type"]]?: (node: Extract, state: TState) => void +} & { + [type in keyof AggregateType]?: (node: AggregateType[type], state: TState) => void +} + +export type AncestorVisitors = { + [type in acorn.AnyNode["type"]]?: ( node: Extract, state: TState, ancestors: acorn.Node[] +) => void +} & { + [type in keyof AggregateType]?: (node: AggregateType[type], state: TState, ancestors: acorn.Node[]) => void +} + +export type WalkerCallback = (node: acorn.Node, state: TState) => void + +export type RecursiveVisitors = { + [type in acorn.AnyNode["type"]]?: ( node: Extract, state: TState, callback: WalkerCallback) => void +} & { + [type in keyof AggregateType]?: (node: AggregateType[type], state: TState, callback: WalkerCallback) => void +} + +export type FindPredicate = (type: string, node: acorn.Node) => boolean + +export interface Found { + node: acorn.Node, + state: TState +} + +/** + * does a 'simple' walk over a tree + * @param node the AST node to walk + * @param visitors an object with properties whose names correspond to node types in the {@link https://github.com/estree/estree | ESTree spec}. The properties should contain functions that will be called with the node object and, if applicable the state at that point. + * @param base a walker algorithm + * @param state a start state. The default walker will simply visit all statements and expressions and not produce a meaningful state. (An example of a use of state is to track scope at each point in the tree.) + */ +export function simple( + node: acorn.Node, + visitors: SimpleVisitors, + base?: RecursiveVisitors, + state?: TState +): void + +/** + * does a 'simple' walk over a tree, building up an array of ancestor nodes (including the current node) and passing the array to the callbacks as a third parameter. + * @param node + * @param visitors + * @param base + * @param state + */ +export function ancestor( + node: acorn.Node, + visitors: AncestorVisitors, + base?: RecursiveVisitors, + state?: TState + ): void + +/** + * does a 'recursive' walk, where the walker functions are responsible for continuing the walk on the child nodes of their target node. + * @param node + * @param state the start state + * @param functions contain an object that maps node types to walker functions + * @param base provides the fallback walker functions for node types that aren't handled in the {@link functions} object. If not given, the default walkers will be used. + */ +export function recursive( + node: acorn.Node, + state: TState, + functions: RecursiveVisitors, + base?: RecursiveVisitors +): void + +/** + * does a 'full' walk over a tree, calling the {@link callback} with the arguments (node, state, type) for each node + * @param node + * @param callback + * @param base + * @param state + */ +export function full( + node: acorn.Node, + callback: FullWalkerCallback, + base?: RecursiveVisitors, + state?: TState +): void + +/** + * does a 'full' walk over a tree, building up an array of ancestor nodes (including the current node) and passing the array to the callbacks as a third parameter. + * @param node + * @param callback + * @param base + * @param state + */ +export function fullAncestor( + node: acorn.Node, + callback: FullAncestorWalkerCallback, + base?: RecursiveVisitors, + state?: TState +): void + +/** + * builds a new walker object by using the walker functions in {@link functions} and filling in the missing ones by taking defaults from {@link base}. + * @param functions + * @param base + */ +export function make( + functions: RecursiveVisitors, + base?: RecursiveVisitors +): RecursiveVisitors + +/** + * tries to locate a node in a tree at the given start and/or end offsets, which satisfies the predicate test. {@link start} and {@link end} can be either `null` (as wildcard) or a `number`. {@link test} may be a string (indicating a node type) or a function that takes (nodeType, node) arguments and returns a boolean indicating whether this node is interesting. {@link base} and {@link state} are optional, and can be used to specify a custom walker. Nodes are tested from inner to outer, so if two nodes match the boundaries, the inner one will be preferred. + * @param node + * @param start + * @param end + * @param type + * @param base + * @param state + */ +export function findNodeAt( + node: acorn.Node, + start: number | undefined, + end?: number | undefined, + type?: FindPredicate | string, + base?: RecursiveVisitors, + state?: TState +): Found | undefined + +/** + * like {@link findNodeAt}, but will match any node that exists 'around' (spanning) the given position. + * @param node + * @param start + * @param type + * @param base + * @param state + */ +export function findNodeAround( + node: acorn.Node, + start: number | undefined, + type?: FindPredicate | string, + base?: RecursiveVisitors, + state?: TState +): Found | undefined + +/** + * Find the outermost matching node after a given position. + */ +export const findNodeAfter: typeof findNodeAround + +/** + * Find the outermost matching node before a given position. + */ +export const findNodeBefore: typeof findNodeAround + +export const base: RecursiveVisitors diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/acorn-walk/dist/walk.js b/novas/novacore-zephyr/groq-code-cli/node_modules/acorn-walk/dist/walk.js new file mode 100644 index 0000000000000000000000000000000000000000..40b7aa1b078a188b1c73c1da60aa4da3ca6da85a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/acorn-walk/dist/walk.js @@ -0,0 +1,455 @@ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : + typeof define === 'function' && define.amd ? define(['exports'], factory) : + (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.acorn = global.acorn || {}, global.acorn.walk = {}))); +})(this, (function (exports) { 'use strict'; + + // AST walker module for ESTree compatible trees + + // A simple walk is one where you simply specify callbacks to be + // called on specific nodes. The last two arguments are optional. A + // simple use would be + // + // walk.simple(myTree, { + // Expression: function(node) { ... } + // }); + // + // to do something with all expressions. All ESTree node types + // can be used to identify node types, as well as Expression and + // Statement, which denote categories of nodes. + // + // The base argument can be used to pass a custom (recursive) + // walker, and state can be used to give this walked an initial + // state. + + function simple(node, visitors, baseVisitor, state, override) { + if (!baseVisitor) { baseVisitor = base + ; }(function c(node, st, override) { + var type = override || node.type; + baseVisitor[type](node, st, c); + if (visitors[type]) { visitors[type](node, st); } + })(node, state, override); + } + + // An ancestor walk keeps an array of ancestor nodes (including the + // current node) and passes them to the callback as third parameter + // (and also as state parameter when no other state is present). + function ancestor(node, visitors, baseVisitor, state, override) { + var ancestors = []; + if (!baseVisitor) { baseVisitor = base + ; }(function c(node, st, override) { + var type = override || node.type; + var isNew = node !== ancestors[ancestors.length - 1]; + if (isNew) { ancestors.push(node); } + baseVisitor[type](node, st, c); + if (visitors[type]) { visitors[type](node, st || ancestors, ancestors); } + if (isNew) { ancestors.pop(); } + })(node, state, override); + } + + // A recursive walk is one where your functions override the default + // walkers. They can modify and replace the state parameter that's + // threaded through the walk, and can opt how and whether to walk + // their child nodes (by calling their third argument on these + // nodes). + function recursive(node, state, funcs, baseVisitor, override) { + var visitor = funcs ? make(funcs, baseVisitor || undefined) : baseVisitor + ;(function c(node, st, override) { + visitor[override || node.type](node, st, c); + })(node, state, override); + } + + function makeTest(test) { + if (typeof test === "string") + { return function (type) { return type === test; } } + else if (!test) + { return function () { return true; } } + else + { return test } + } + + var Found = function Found(node, state) { this.node = node; this.state = state; }; + + // A full walk triggers the callback on each node + function full(node, callback, baseVisitor, state, override) { + if (!baseVisitor) { baseVisitor = base; } + var last + ;(function c(node, st, override) { + var type = override || node.type; + baseVisitor[type](node, st, c); + if (last !== node) { + callback(node, st, type); + last = node; + } + })(node, state, override); + } + + // An fullAncestor walk is like an ancestor walk, but triggers + // the callback on each node + function fullAncestor(node, callback, baseVisitor, state) { + if (!baseVisitor) { baseVisitor = base; } + var ancestors = [], last + ;(function c(node, st, override) { + var type = override || node.type; + var isNew = node !== ancestors[ancestors.length - 1]; + if (isNew) { ancestors.push(node); } + baseVisitor[type](node, st, c); + if (last !== node) { + callback(node, st || ancestors, ancestors, type); + last = node; + } + if (isNew) { ancestors.pop(); } + })(node, state); + } + + // Find a node with a given start, end, and type (all are optional, + // null can be used as wildcard). Returns a {node, state} object, or + // undefined when it doesn't find a matching node. + function findNodeAt(node, start, end, test, baseVisitor, state) { + if (!baseVisitor) { baseVisitor = base; } + test = makeTest(test); + try { + (function c(node, st, override) { + var type = override || node.type; + if ((start == null || node.start <= start) && + (end == null || node.end >= end)) + { baseVisitor[type](node, st, c); } + if ((start == null || node.start === start) && + (end == null || node.end === end) && + test(type, node)) + { throw new Found(node, st) } + })(node, state); + } catch (e) { + if (e instanceof Found) { return e } + throw e + } + } + + // Find the innermost node of a given type that contains the given + // position. Interface similar to findNodeAt. + function findNodeAround(node, pos, test, baseVisitor, state) { + test = makeTest(test); + if (!baseVisitor) { baseVisitor = base; } + try { + (function c(node, st, override) { + var type = override || node.type; + if (node.start > pos || node.end < pos) { return } + baseVisitor[type](node, st, c); + if (test(type, node)) { throw new Found(node, st) } + })(node, state); + } catch (e) { + if (e instanceof Found) { return e } + throw e + } + } + + // Find the outermost matching node after a given position. + function findNodeAfter(node, pos, test, baseVisitor, state) { + test = makeTest(test); + if (!baseVisitor) { baseVisitor = base; } + try { + (function c(node, st, override) { + if (node.end < pos) { return } + var type = override || node.type; + if (node.start >= pos && test(type, node)) { throw new Found(node, st) } + baseVisitor[type](node, st, c); + })(node, state); + } catch (e) { + if (e instanceof Found) { return e } + throw e + } + } + + // Find the outermost matching node before a given position. + function findNodeBefore(node, pos, test, baseVisitor, state) { + test = makeTest(test); + if (!baseVisitor) { baseVisitor = base; } + var max + ;(function c(node, st, override) { + if (node.start > pos) { return } + var type = override || node.type; + if (node.end <= pos && (!max || max.node.end < node.end) && test(type, node)) + { max = new Found(node, st); } + baseVisitor[type](node, st, c); + })(node, state); + return max + } + + // Used to create a custom walker. Will fill in all missing node + // type properties with the defaults. + function make(funcs, baseVisitor) { + var visitor = Object.create(baseVisitor || base); + for (var type in funcs) { visitor[type] = funcs[type]; } + return visitor + } + + function skipThrough(node, st, c) { c(node, st); } + function ignore(_node, _st, _c) {} + + // Node walkers. + + var base = {}; + + base.Program = base.BlockStatement = base.StaticBlock = function (node, st, c) { + for (var i = 0, list = node.body; i < list.length; i += 1) + { + var stmt = list[i]; + + c(stmt, st, "Statement"); + } + }; + base.Statement = skipThrough; + base.EmptyStatement = ignore; + base.ExpressionStatement = base.ParenthesizedExpression = base.ChainExpression = + function (node, st, c) { return c(node.expression, st, "Expression"); }; + base.IfStatement = function (node, st, c) { + c(node.test, st, "Expression"); + c(node.consequent, st, "Statement"); + if (node.alternate) { c(node.alternate, st, "Statement"); } + }; + base.LabeledStatement = function (node, st, c) { return c(node.body, st, "Statement"); }; + base.BreakStatement = base.ContinueStatement = ignore; + base.WithStatement = function (node, st, c) { + c(node.object, st, "Expression"); + c(node.body, st, "Statement"); + }; + base.SwitchStatement = function (node, st, c) { + c(node.discriminant, st, "Expression"); + for (var i = 0, list = node.cases; i < list.length; i += 1) { + var cs = list[i]; + + c(cs, st); + } + }; + base.SwitchCase = function (node, st, c) { + if (node.test) { c(node.test, st, "Expression"); } + for (var i = 0, list = node.consequent; i < list.length; i += 1) + { + var cons = list[i]; + + c(cons, st, "Statement"); + } + }; + base.ReturnStatement = base.YieldExpression = base.AwaitExpression = function (node, st, c) { + if (node.argument) { c(node.argument, st, "Expression"); } + }; + base.ThrowStatement = base.SpreadElement = + function (node, st, c) { return c(node.argument, st, "Expression"); }; + base.TryStatement = function (node, st, c) { + c(node.block, st, "Statement"); + if (node.handler) { c(node.handler, st); } + if (node.finalizer) { c(node.finalizer, st, "Statement"); } + }; + base.CatchClause = function (node, st, c) { + if (node.param) { c(node.param, st, "Pattern"); } + c(node.body, st, "Statement"); + }; + base.WhileStatement = base.DoWhileStatement = function (node, st, c) { + c(node.test, st, "Expression"); + c(node.body, st, "Statement"); + }; + base.ForStatement = function (node, st, c) { + if (node.init) { c(node.init, st, "ForInit"); } + if (node.test) { c(node.test, st, "Expression"); } + if (node.update) { c(node.update, st, "Expression"); } + c(node.body, st, "Statement"); + }; + base.ForInStatement = base.ForOfStatement = function (node, st, c) { + c(node.left, st, "ForInit"); + c(node.right, st, "Expression"); + c(node.body, st, "Statement"); + }; + base.ForInit = function (node, st, c) { + if (node.type === "VariableDeclaration") { c(node, st); } + else { c(node, st, "Expression"); } + }; + base.DebuggerStatement = ignore; + + base.FunctionDeclaration = function (node, st, c) { return c(node, st, "Function"); }; + base.VariableDeclaration = function (node, st, c) { + for (var i = 0, list = node.declarations; i < list.length; i += 1) + { + var decl = list[i]; + + c(decl, st); + } + }; + base.VariableDeclarator = function (node, st, c) { + c(node.id, st, "Pattern"); + if (node.init) { c(node.init, st, "Expression"); } + }; + + base.Function = function (node, st, c) { + if (node.id) { c(node.id, st, "Pattern"); } + for (var i = 0, list = node.params; i < list.length; i += 1) + { + var param = list[i]; + + c(param, st, "Pattern"); + } + c(node.body, st, node.expression ? "Expression" : "Statement"); + }; + + base.Pattern = function (node, st, c) { + if (node.type === "Identifier") + { c(node, st, "VariablePattern"); } + else if (node.type === "MemberExpression") + { c(node, st, "MemberPattern"); } + else + { c(node, st); } + }; + base.VariablePattern = ignore; + base.MemberPattern = skipThrough; + base.RestElement = function (node, st, c) { return c(node.argument, st, "Pattern"); }; + base.ArrayPattern = function (node, st, c) { + for (var i = 0, list = node.elements; i < list.length; i += 1) { + var elt = list[i]; + + if (elt) { c(elt, st, "Pattern"); } + } + }; + base.ObjectPattern = function (node, st, c) { + for (var i = 0, list = node.properties; i < list.length; i += 1) { + var prop = list[i]; + + if (prop.type === "Property") { + if (prop.computed) { c(prop.key, st, "Expression"); } + c(prop.value, st, "Pattern"); + } else if (prop.type === "RestElement") { + c(prop.argument, st, "Pattern"); + } + } + }; + + base.Expression = skipThrough; + base.ThisExpression = base.Super = base.MetaProperty = ignore; + base.ArrayExpression = function (node, st, c) { + for (var i = 0, list = node.elements; i < list.length; i += 1) { + var elt = list[i]; + + if (elt) { c(elt, st, "Expression"); } + } + }; + base.ObjectExpression = function (node, st, c) { + for (var i = 0, list = node.properties; i < list.length; i += 1) + { + var prop = list[i]; + + c(prop, st); + } + }; + base.FunctionExpression = base.ArrowFunctionExpression = base.FunctionDeclaration; + base.SequenceExpression = function (node, st, c) { + for (var i = 0, list = node.expressions; i < list.length; i += 1) + { + var expr = list[i]; + + c(expr, st, "Expression"); + } + }; + base.TemplateLiteral = function (node, st, c) { + for (var i = 0, list = node.quasis; i < list.length; i += 1) + { + var quasi = list[i]; + + c(quasi, st); + } + + for (var i$1 = 0, list$1 = node.expressions; i$1 < list$1.length; i$1 += 1) + { + var expr = list$1[i$1]; + + c(expr, st, "Expression"); + } + }; + base.TemplateElement = ignore; + base.UnaryExpression = base.UpdateExpression = function (node, st, c) { + c(node.argument, st, "Expression"); + }; + base.BinaryExpression = base.LogicalExpression = function (node, st, c) { + c(node.left, st, "Expression"); + c(node.right, st, "Expression"); + }; + base.AssignmentExpression = base.AssignmentPattern = function (node, st, c) { + c(node.left, st, "Pattern"); + c(node.right, st, "Expression"); + }; + base.ConditionalExpression = function (node, st, c) { + c(node.test, st, "Expression"); + c(node.consequent, st, "Expression"); + c(node.alternate, st, "Expression"); + }; + base.NewExpression = base.CallExpression = function (node, st, c) { + c(node.callee, st, "Expression"); + if (node.arguments) + { for (var i = 0, list = node.arguments; i < list.length; i += 1) + { + var arg = list[i]; + + c(arg, st, "Expression"); + } } + }; + base.MemberExpression = function (node, st, c) { + c(node.object, st, "Expression"); + if (node.computed) { c(node.property, st, "Expression"); } + }; + base.ExportNamedDeclaration = base.ExportDefaultDeclaration = function (node, st, c) { + if (node.declaration) + { c(node.declaration, st, node.type === "ExportNamedDeclaration" || node.declaration.id ? "Statement" : "Expression"); } + if (node.source) { c(node.source, st, "Expression"); } + }; + base.ExportAllDeclaration = function (node, st, c) { + if (node.exported) + { c(node.exported, st); } + c(node.source, st, "Expression"); + }; + base.ImportDeclaration = function (node, st, c) { + for (var i = 0, list = node.specifiers; i < list.length; i += 1) + { + var spec = list[i]; + + c(spec, st); + } + c(node.source, st, "Expression"); + }; + base.ImportExpression = function (node, st, c) { + c(node.source, st, "Expression"); + }; + base.ImportSpecifier = base.ImportDefaultSpecifier = base.ImportNamespaceSpecifier = base.Identifier = base.PrivateIdentifier = base.Literal = ignore; + + base.TaggedTemplateExpression = function (node, st, c) { + c(node.tag, st, "Expression"); + c(node.quasi, st, "Expression"); + }; + base.ClassDeclaration = base.ClassExpression = function (node, st, c) { return c(node, st, "Class"); }; + base.Class = function (node, st, c) { + if (node.id) { c(node.id, st, "Pattern"); } + if (node.superClass) { c(node.superClass, st, "Expression"); } + c(node.body, st); + }; + base.ClassBody = function (node, st, c) { + for (var i = 0, list = node.body; i < list.length; i += 1) + { + var elt = list[i]; + + c(elt, st); + } + }; + base.MethodDefinition = base.PropertyDefinition = base.Property = function (node, st, c) { + if (node.computed) { c(node.key, st, "Expression"); } + if (node.value) { c(node.value, st, "Expression"); } + }; + + exports.ancestor = ancestor; + exports.base = base; + exports.findNodeAfter = findNodeAfter; + exports.findNodeAround = findNodeAround; + exports.findNodeAt = findNodeAt; + exports.findNodeBefore = findNodeBefore; + exports.full = full; + exports.fullAncestor = fullAncestor; + exports.make = make; + exports.recursive = recursive; + exports.simple = simple; + +})); diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/acorn-walk/dist/walk.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/acorn-walk/dist/walk.mjs new file mode 100644 index 0000000000000000000000000000000000000000..c475ababc7ac308be115a413c5a8372e9eaa4cd0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/acorn-walk/dist/walk.mjs @@ -0,0 +1,437 @@ +// AST walker module for ESTree compatible trees + +// A simple walk is one where you simply specify callbacks to be +// called on specific nodes. The last two arguments are optional. A +// simple use would be +// +// walk.simple(myTree, { +// Expression: function(node) { ... } +// }); +// +// to do something with all expressions. All ESTree node types +// can be used to identify node types, as well as Expression and +// Statement, which denote categories of nodes. +// +// The base argument can be used to pass a custom (recursive) +// walker, and state can be used to give this walked an initial +// state. + +function simple(node, visitors, baseVisitor, state, override) { + if (!baseVisitor) { baseVisitor = base + ; }(function c(node, st, override) { + var type = override || node.type; + baseVisitor[type](node, st, c); + if (visitors[type]) { visitors[type](node, st); } + })(node, state, override); +} + +// An ancestor walk keeps an array of ancestor nodes (including the +// current node) and passes them to the callback as third parameter +// (and also as state parameter when no other state is present). +function ancestor(node, visitors, baseVisitor, state, override) { + var ancestors = []; + if (!baseVisitor) { baseVisitor = base + ; }(function c(node, st, override) { + var type = override || node.type; + var isNew = node !== ancestors[ancestors.length - 1]; + if (isNew) { ancestors.push(node); } + baseVisitor[type](node, st, c); + if (visitors[type]) { visitors[type](node, st || ancestors, ancestors); } + if (isNew) { ancestors.pop(); } + })(node, state, override); +} + +// A recursive walk is one where your functions override the default +// walkers. They can modify and replace the state parameter that's +// threaded through the walk, and can opt how and whether to walk +// their child nodes (by calling their third argument on these +// nodes). +function recursive(node, state, funcs, baseVisitor, override) { + var visitor = funcs ? make(funcs, baseVisitor || undefined) : baseVisitor + ;(function c(node, st, override) { + visitor[override || node.type](node, st, c); + })(node, state, override); +} + +function makeTest(test) { + if (typeof test === "string") + { return function (type) { return type === test; } } + else if (!test) + { return function () { return true; } } + else + { return test } +} + +var Found = function Found(node, state) { this.node = node; this.state = state; }; + +// A full walk triggers the callback on each node +function full(node, callback, baseVisitor, state, override) { + if (!baseVisitor) { baseVisitor = base; } + var last + ;(function c(node, st, override) { + var type = override || node.type; + baseVisitor[type](node, st, c); + if (last !== node) { + callback(node, st, type); + last = node; + } + })(node, state, override); +} + +// An fullAncestor walk is like an ancestor walk, but triggers +// the callback on each node +function fullAncestor(node, callback, baseVisitor, state) { + if (!baseVisitor) { baseVisitor = base; } + var ancestors = [], last + ;(function c(node, st, override) { + var type = override || node.type; + var isNew = node !== ancestors[ancestors.length - 1]; + if (isNew) { ancestors.push(node); } + baseVisitor[type](node, st, c); + if (last !== node) { + callback(node, st || ancestors, ancestors, type); + last = node; + } + if (isNew) { ancestors.pop(); } + })(node, state); +} + +// Find a node with a given start, end, and type (all are optional, +// null can be used as wildcard). Returns a {node, state} object, or +// undefined when it doesn't find a matching node. +function findNodeAt(node, start, end, test, baseVisitor, state) { + if (!baseVisitor) { baseVisitor = base; } + test = makeTest(test); + try { + (function c(node, st, override) { + var type = override || node.type; + if ((start == null || node.start <= start) && + (end == null || node.end >= end)) + { baseVisitor[type](node, st, c); } + if ((start == null || node.start === start) && + (end == null || node.end === end) && + test(type, node)) + { throw new Found(node, st) } + })(node, state); + } catch (e) { + if (e instanceof Found) { return e } + throw e + } +} + +// Find the innermost node of a given type that contains the given +// position. Interface similar to findNodeAt. +function findNodeAround(node, pos, test, baseVisitor, state) { + test = makeTest(test); + if (!baseVisitor) { baseVisitor = base; } + try { + (function c(node, st, override) { + var type = override || node.type; + if (node.start > pos || node.end < pos) { return } + baseVisitor[type](node, st, c); + if (test(type, node)) { throw new Found(node, st) } + })(node, state); + } catch (e) { + if (e instanceof Found) { return e } + throw e + } +} + +// Find the outermost matching node after a given position. +function findNodeAfter(node, pos, test, baseVisitor, state) { + test = makeTest(test); + if (!baseVisitor) { baseVisitor = base; } + try { + (function c(node, st, override) { + if (node.end < pos) { return } + var type = override || node.type; + if (node.start >= pos && test(type, node)) { throw new Found(node, st) } + baseVisitor[type](node, st, c); + })(node, state); + } catch (e) { + if (e instanceof Found) { return e } + throw e + } +} + +// Find the outermost matching node before a given position. +function findNodeBefore(node, pos, test, baseVisitor, state) { + test = makeTest(test); + if (!baseVisitor) { baseVisitor = base; } + var max + ;(function c(node, st, override) { + if (node.start > pos) { return } + var type = override || node.type; + if (node.end <= pos && (!max || max.node.end < node.end) && test(type, node)) + { max = new Found(node, st); } + baseVisitor[type](node, st, c); + })(node, state); + return max +} + +// Used to create a custom walker. Will fill in all missing node +// type properties with the defaults. +function make(funcs, baseVisitor) { + var visitor = Object.create(baseVisitor || base); + for (var type in funcs) { visitor[type] = funcs[type]; } + return visitor +} + +function skipThrough(node, st, c) { c(node, st); } +function ignore(_node, _st, _c) {} + +// Node walkers. + +var base = {}; + +base.Program = base.BlockStatement = base.StaticBlock = function (node, st, c) { + for (var i = 0, list = node.body; i < list.length; i += 1) + { + var stmt = list[i]; + + c(stmt, st, "Statement"); + } +}; +base.Statement = skipThrough; +base.EmptyStatement = ignore; +base.ExpressionStatement = base.ParenthesizedExpression = base.ChainExpression = + function (node, st, c) { return c(node.expression, st, "Expression"); }; +base.IfStatement = function (node, st, c) { + c(node.test, st, "Expression"); + c(node.consequent, st, "Statement"); + if (node.alternate) { c(node.alternate, st, "Statement"); } +}; +base.LabeledStatement = function (node, st, c) { return c(node.body, st, "Statement"); }; +base.BreakStatement = base.ContinueStatement = ignore; +base.WithStatement = function (node, st, c) { + c(node.object, st, "Expression"); + c(node.body, st, "Statement"); +}; +base.SwitchStatement = function (node, st, c) { + c(node.discriminant, st, "Expression"); + for (var i = 0, list = node.cases; i < list.length; i += 1) { + var cs = list[i]; + + c(cs, st); + } +}; +base.SwitchCase = function (node, st, c) { + if (node.test) { c(node.test, st, "Expression"); } + for (var i = 0, list = node.consequent; i < list.length; i += 1) + { + var cons = list[i]; + + c(cons, st, "Statement"); + } +}; +base.ReturnStatement = base.YieldExpression = base.AwaitExpression = function (node, st, c) { + if (node.argument) { c(node.argument, st, "Expression"); } +}; +base.ThrowStatement = base.SpreadElement = + function (node, st, c) { return c(node.argument, st, "Expression"); }; +base.TryStatement = function (node, st, c) { + c(node.block, st, "Statement"); + if (node.handler) { c(node.handler, st); } + if (node.finalizer) { c(node.finalizer, st, "Statement"); } +}; +base.CatchClause = function (node, st, c) { + if (node.param) { c(node.param, st, "Pattern"); } + c(node.body, st, "Statement"); +}; +base.WhileStatement = base.DoWhileStatement = function (node, st, c) { + c(node.test, st, "Expression"); + c(node.body, st, "Statement"); +}; +base.ForStatement = function (node, st, c) { + if (node.init) { c(node.init, st, "ForInit"); } + if (node.test) { c(node.test, st, "Expression"); } + if (node.update) { c(node.update, st, "Expression"); } + c(node.body, st, "Statement"); +}; +base.ForInStatement = base.ForOfStatement = function (node, st, c) { + c(node.left, st, "ForInit"); + c(node.right, st, "Expression"); + c(node.body, st, "Statement"); +}; +base.ForInit = function (node, st, c) { + if (node.type === "VariableDeclaration") { c(node, st); } + else { c(node, st, "Expression"); } +}; +base.DebuggerStatement = ignore; + +base.FunctionDeclaration = function (node, st, c) { return c(node, st, "Function"); }; +base.VariableDeclaration = function (node, st, c) { + for (var i = 0, list = node.declarations; i < list.length; i += 1) + { + var decl = list[i]; + + c(decl, st); + } +}; +base.VariableDeclarator = function (node, st, c) { + c(node.id, st, "Pattern"); + if (node.init) { c(node.init, st, "Expression"); } +}; + +base.Function = function (node, st, c) { + if (node.id) { c(node.id, st, "Pattern"); } + for (var i = 0, list = node.params; i < list.length; i += 1) + { + var param = list[i]; + + c(param, st, "Pattern"); + } + c(node.body, st, node.expression ? "Expression" : "Statement"); +}; + +base.Pattern = function (node, st, c) { + if (node.type === "Identifier") + { c(node, st, "VariablePattern"); } + else if (node.type === "MemberExpression") + { c(node, st, "MemberPattern"); } + else + { c(node, st); } +}; +base.VariablePattern = ignore; +base.MemberPattern = skipThrough; +base.RestElement = function (node, st, c) { return c(node.argument, st, "Pattern"); }; +base.ArrayPattern = function (node, st, c) { + for (var i = 0, list = node.elements; i < list.length; i += 1) { + var elt = list[i]; + + if (elt) { c(elt, st, "Pattern"); } + } +}; +base.ObjectPattern = function (node, st, c) { + for (var i = 0, list = node.properties; i < list.length; i += 1) { + var prop = list[i]; + + if (prop.type === "Property") { + if (prop.computed) { c(prop.key, st, "Expression"); } + c(prop.value, st, "Pattern"); + } else if (prop.type === "RestElement") { + c(prop.argument, st, "Pattern"); + } + } +}; + +base.Expression = skipThrough; +base.ThisExpression = base.Super = base.MetaProperty = ignore; +base.ArrayExpression = function (node, st, c) { + for (var i = 0, list = node.elements; i < list.length; i += 1) { + var elt = list[i]; + + if (elt) { c(elt, st, "Expression"); } + } +}; +base.ObjectExpression = function (node, st, c) { + for (var i = 0, list = node.properties; i < list.length; i += 1) + { + var prop = list[i]; + + c(prop, st); + } +}; +base.FunctionExpression = base.ArrowFunctionExpression = base.FunctionDeclaration; +base.SequenceExpression = function (node, st, c) { + for (var i = 0, list = node.expressions; i < list.length; i += 1) + { + var expr = list[i]; + + c(expr, st, "Expression"); + } +}; +base.TemplateLiteral = function (node, st, c) { + for (var i = 0, list = node.quasis; i < list.length; i += 1) + { + var quasi = list[i]; + + c(quasi, st); + } + + for (var i$1 = 0, list$1 = node.expressions; i$1 < list$1.length; i$1 += 1) + { + var expr = list$1[i$1]; + + c(expr, st, "Expression"); + } +}; +base.TemplateElement = ignore; +base.UnaryExpression = base.UpdateExpression = function (node, st, c) { + c(node.argument, st, "Expression"); +}; +base.BinaryExpression = base.LogicalExpression = function (node, st, c) { + c(node.left, st, "Expression"); + c(node.right, st, "Expression"); +}; +base.AssignmentExpression = base.AssignmentPattern = function (node, st, c) { + c(node.left, st, "Pattern"); + c(node.right, st, "Expression"); +}; +base.ConditionalExpression = function (node, st, c) { + c(node.test, st, "Expression"); + c(node.consequent, st, "Expression"); + c(node.alternate, st, "Expression"); +}; +base.NewExpression = base.CallExpression = function (node, st, c) { + c(node.callee, st, "Expression"); + if (node.arguments) + { for (var i = 0, list = node.arguments; i < list.length; i += 1) + { + var arg = list[i]; + + c(arg, st, "Expression"); + } } +}; +base.MemberExpression = function (node, st, c) { + c(node.object, st, "Expression"); + if (node.computed) { c(node.property, st, "Expression"); } +}; +base.ExportNamedDeclaration = base.ExportDefaultDeclaration = function (node, st, c) { + if (node.declaration) + { c(node.declaration, st, node.type === "ExportNamedDeclaration" || node.declaration.id ? "Statement" : "Expression"); } + if (node.source) { c(node.source, st, "Expression"); } +}; +base.ExportAllDeclaration = function (node, st, c) { + if (node.exported) + { c(node.exported, st); } + c(node.source, st, "Expression"); +}; +base.ImportDeclaration = function (node, st, c) { + for (var i = 0, list = node.specifiers; i < list.length; i += 1) + { + var spec = list[i]; + + c(spec, st); + } + c(node.source, st, "Expression"); +}; +base.ImportExpression = function (node, st, c) { + c(node.source, st, "Expression"); +}; +base.ImportSpecifier = base.ImportDefaultSpecifier = base.ImportNamespaceSpecifier = base.Identifier = base.PrivateIdentifier = base.Literal = ignore; + +base.TaggedTemplateExpression = function (node, st, c) { + c(node.tag, st, "Expression"); + c(node.quasi, st, "Expression"); +}; +base.ClassDeclaration = base.ClassExpression = function (node, st, c) { return c(node, st, "Class"); }; +base.Class = function (node, st, c) { + if (node.id) { c(node.id, st, "Pattern"); } + if (node.superClass) { c(node.superClass, st, "Expression"); } + c(node.body, st); +}; +base.ClassBody = function (node, st, c) { + for (var i = 0, list = node.body; i < list.length; i += 1) + { + var elt = list[i]; + + c(elt, st); + } +}; +base.MethodDefinition = base.PropertyDefinition = base.Property = function (node, st, c) { + if (node.computed) { c(node.key, st, "Expression"); } + if (node.value) { c(node.value, st, "Expression"); } +}; + +export { ancestor, base, findNodeAfter, findNodeAround, findNodeAt, findNodeBefore, full, fullAncestor, make, recursive, simple }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/acorn/bin/acorn b/novas/novacore-zephyr/groq-code-cli/node_modules/acorn/bin/acorn new file mode 100644 index 0000000000000000000000000000000000000000..3ef3c124b08bd4fb0f27cd13301dfeeae4a6464c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/acorn/bin/acorn @@ -0,0 +1,4 @@ +#!/usr/bin/env node +"use strict" + +require("../dist/bin.js") diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/acorn/dist/acorn.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/acorn/dist/acorn.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..f2ec5243bcb2625afcc11f4296b4250ca858c431 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/acorn/dist/acorn.d.mts @@ -0,0 +1,883 @@ +export interface Node { + start: number + end: number + type: string + range?: [number, number] + loc?: SourceLocation | null +} + +export interface SourceLocation { + source?: string | null + start: Position + end: Position +} + +export interface Position { + /** 1-based */ + line: number + /** 0-based */ + column: number +} + +export interface Identifier extends Node { + type: "Identifier" + name: string +} + +export interface Literal extends Node { + type: "Literal" + value?: string | boolean | null | number | RegExp | bigint + raw?: string + regex?: { + pattern: string + flags: string + } + bigint?: string +} + +export interface Program extends Node { + type: "Program" + body: Array + sourceType: "script" | "module" +} + +export interface Function extends Node { + id?: Identifier | null + params: Array + body: BlockStatement | Expression + generator: boolean + expression: boolean + async: boolean +} + +export interface ExpressionStatement extends Node { + type: "ExpressionStatement" + expression: Expression | Literal + directive?: string +} + +export interface BlockStatement extends Node { + type: "BlockStatement" + body: Array +} + +export interface EmptyStatement extends Node { + type: "EmptyStatement" +} + +export interface DebuggerStatement extends Node { + type: "DebuggerStatement" +} + +export interface WithStatement extends Node { + type: "WithStatement" + object: Expression + body: Statement +} + +export interface ReturnStatement extends Node { + type: "ReturnStatement" + argument?: Expression | null +} + +export interface LabeledStatement extends Node { + type: "LabeledStatement" + label: Identifier + body: Statement +} + +export interface BreakStatement extends Node { + type: "BreakStatement" + label?: Identifier | null +} + +export interface ContinueStatement extends Node { + type: "ContinueStatement" + label?: Identifier | null +} + +export interface IfStatement extends Node { + type: "IfStatement" + test: Expression + consequent: Statement + alternate?: Statement | null +} + +export interface SwitchStatement extends Node { + type: "SwitchStatement" + discriminant: Expression + cases: Array +} + +export interface SwitchCase extends Node { + type: "SwitchCase" + test?: Expression | null + consequent: Array +} + +export interface ThrowStatement extends Node { + type: "ThrowStatement" + argument: Expression +} + +export interface TryStatement extends Node { + type: "TryStatement" + block: BlockStatement + handler?: CatchClause | null + finalizer?: BlockStatement | null +} + +export interface CatchClause extends Node { + type: "CatchClause" + param?: Pattern | null + body: BlockStatement +} + +export interface WhileStatement extends Node { + type: "WhileStatement" + test: Expression + body: Statement +} + +export interface DoWhileStatement extends Node { + type: "DoWhileStatement" + body: Statement + test: Expression +} + +export interface ForStatement extends Node { + type: "ForStatement" + init?: VariableDeclaration | Expression | null + test?: Expression | null + update?: Expression | null + body: Statement +} + +export interface ForInStatement extends Node { + type: "ForInStatement" + left: VariableDeclaration | Pattern + right: Expression + body: Statement +} + +export interface FunctionDeclaration extends Function { + type: "FunctionDeclaration" + id: Identifier + body: BlockStatement +} + +export interface VariableDeclaration extends Node { + type: "VariableDeclaration" + declarations: Array + kind: "var" | "let" | "const" | "using" | "await using" +} + +export interface VariableDeclarator extends Node { + type: "VariableDeclarator" + id: Pattern + init?: Expression | null +} + +export interface ThisExpression extends Node { + type: "ThisExpression" +} + +export interface ArrayExpression extends Node { + type: "ArrayExpression" + elements: Array +} + +export interface ObjectExpression extends Node { + type: "ObjectExpression" + properties: Array +} + +export interface Property extends Node { + type: "Property" + key: Expression + value: Expression + kind: "init" | "get" | "set" + method: boolean + shorthand: boolean + computed: boolean +} + +export interface FunctionExpression extends Function { + type: "FunctionExpression" + body: BlockStatement +} + +export interface UnaryExpression extends Node { + type: "UnaryExpression" + operator: UnaryOperator + prefix: boolean + argument: Expression +} + +export type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete" + +export interface UpdateExpression extends Node { + type: "UpdateExpression" + operator: UpdateOperator + argument: Expression + prefix: boolean +} + +export type UpdateOperator = "++" | "--" + +export interface BinaryExpression extends Node { + type: "BinaryExpression" + operator: BinaryOperator + left: Expression | PrivateIdentifier + right: Expression +} + +export type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "|" | "^" | "&" | "in" | "instanceof" | "**" + +export interface AssignmentExpression extends Node { + type: "AssignmentExpression" + operator: AssignmentOperator + left: Pattern + right: Expression +} + +export type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "**=" | "||=" | "&&=" | "??=" + +export interface LogicalExpression extends Node { + type: "LogicalExpression" + operator: LogicalOperator + left: Expression + right: Expression +} + +export type LogicalOperator = "||" | "&&" | "??" + +export interface MemberExpression extends Node { + type: "MemberExpression" + object: Expression | Super + property: Expression | PrivateIdentifier + computed: boolean + optional: boolean +} + +export interface ConditionalExpression extends Node { + type: "ConditionalExpression" + test: Expression + alternate: Expression + consequent: Expression +} + +export interface CallExpression extends Node { + type: "CallExpression" + callee: Expression | Super + arguments: Array + optional: boolean +} + +export interface NewExpression extends Node { + type: "NewExpression" + callee: Expression + arguments: Array +} + +export interface SequenceExpression extends Node { + type: "SequenceExpression" + expressions: Array +} + +export interface ForOfStatement extends Node { + type: "ForOfStatement" + left: VariableDeclaration | Pattern + right: Expression + body: Statement + await: boolean +} + +export interface Super extends Node { + type: "Super" +} + +export interface SpreadElement extends Node { + type: "SpreadElement" + argument: Expression +} + +export interface ArrowFunctionExpression extends Function { + type: "ArrowFunctionExpression" +} + +export interface YieldExpression extends Node { + type: "YieldExpression" + argument?: Expression | null + delegate: boolean +} + +export interface TemplateLiteral extends Node { + type: "TemplateLiteral" + quasis: Array + expressions: Array +} + +export interface TaggedTemplateExpression extends Node { + type: "TaggedTemplateExpression" + tag: Expression + quasi: TemplateLiteral +} + +export interface TemplateElement extends Node { + type: "TemplateElement" + tail: boolean + value: { + cooked?: string | null + raw: string + } +} + +export interface AssignmentProperty extends Node { + type: "Property" + key: Expression + value: Pattern + kind: "init" + method: false + shorthand: boolean + computed: boolean +} + +export interface ObjectPattern extends Node { + type: "ObjectPattern" + properties: Array +} + +export interface ArrayPattern extends Node { + type: "ArrayPattern" + elements: Array +} + +export interface RestElement extends Node { + type: "RestElement" + argument: Pattern +} + +export interface AssignmentPattern extends Node { + type: "AssignmentPattern" + left: Pattern + right: Expression +} + +export interface Class extends Node { + id?: Identifier | null + superClass?: Expression | null + body: ClassBody +} + +export interface ClassBody extends Node { + type: "ClassBody" + body: Array +} + +export interface MethodDefinition extends Node { + type: "MethodDefinition" + key: Expression | PrivateIdentifier + value: FunctionExpression + kind: "constructor" | "method" | "get" | "set" + computed: boolean + static: boolean +} + +export interface ClassDeclaration extends Class { + type: "ClassDeclaration" + id: Identifier +} + +export interface ClassExpression extends Class { + type: "ClassExpression" +} + +export interface MetaProperty extends Node { + type: "MetaProperty" + meta: Identifier + property: Identifier +} + +export interface ImportDeclaration extends Node { + type: "ImportDeclaration" + specifiers: Array + source: Literal + attributes: Array +} + +export interface ImportSpecifier extends Node { + type: "ImportSpecifier" + imported: Identifier | Literal + local: Identifier +} + +export interface ImportDefaultSpecifier extends Node { + type: "ImportDefaultSpecifier" + local: Identifier +} + +export interface ImportNamespaceSpecifier extends Node { + type: "ImportNamespaceSpecifier" + local: Identifier +} + +export interface ImportAttribute extends Node { + type: "ImportAttribute" + key: Identifier | Literal + value: Literal +} + +export interface ExportNamedDeclaration extends Node { + type: "ExportNamedDeclaration" + declaration?: Declaration | null + specifiers: Array + source?: Literal | null + attributes: Array +} + +export interface ExportSpecifier extends Node { + type: "ExportSpecifier" + exported: Identifier | Literal + local: Identifier | Literal +} + +export interface AnonymousFunctionDeclaration extends Function { + type: "FunctionDeclaration" + id: null + body: BlockStatement +} + +export interface AnonymousClassDeclaration extends Class { + type: "ClassDeclaration" + id: null +} + +export interface ExportDefaultDeclaration extends Node { + type: "ExportDefaultDeclaration" + declaration: AnonymousFunctionDeclaration | FunctionDeclaration | AnonymousClassDeclaration | ClassDeclaration | Expression +} + +export interface ExportAllDeclaration extends Node { + type: "ExportAllDeclaration" + source: Literal + exported?: Identifier | Literal | null + attributes: Array +} + +export interface AwaitExpression extends Node { + type: "AwaitExpression" + argument: Expression +} + +export interface ChainExpression extends Node { + type: "ChainExpression" + expression: MemberExpression | CallExpression +} + +export interface ImportExpression extends Node { + type: "ImportExpression" + source: Expression + options: Expression | null +} + +export interface ParenthesizedExpression extends Node { + type: "ParenthesizedExpression" + expression: Expression +} + +export interface PropertyDefinition extends Node { + type: "PropertyDefinition" + key: Expression | PrivateIdentifier + value?: Expression | null + computed: boolean + static: boolean +} + +export interface PrivateIdentifier extends Node { + type: "PrivateIdentifier" + name: string +} + +export interface StaticBlock extends Node { + type: "StaticBlock" + body: Array +} + +export type Statement = +| ExpressionStatement +| BlockStatement +| EmptyStatement +| DebuggerStatement +| WithStatement +| ReturnStatement +| LabeledStatement +| BreakStatement +| ContinueStatement +| IfStatement +| SwitchStatement +| ThrowStatement +| TryStatement +| WhileStatement +| DoWhileStatement +| ForStatement +| ForInStatement +| ForOfStatement +| Declaration + +export type Declaration = +| FunctionDeclaration +| VariableDeclaration +| ClassDeclaration + +export type Expression = +| Identifier +| Literal +| ThisExpression +| ArrayExpression +| ObjectExpression +| FunctionExpression +| UnaryExpression +| UpdateExpression +| BinaryExpression +| AssignmentExpression +| LogicalExpression +| MemberExpression +| ConditionalExpression +| CallExpression +| NewExpression +| SequenceExpression +| ArrowFunctionExpression +| YieldExpression +| TemplateLiteral +| TaggedTemplateExpression +| ClassExpression +| MetaProperty +| AwaitExpression +| ChainExpression +| ImportExpression +| ParenthesizedExpression + +export type Pattern = +| Identifier +| MemberExpression +| ObjectPattern +| ArrayPattern +| RestElement +| AssignmentPattern + +export type ModuleDeclaration = +| ImportDeclaration +| ExportNamedDeclaration +| ExportDefaultDeclaration +| ExportAllDeclaration + +/** + * This interface is only used for defining {@link AnyNode}. + * It exists so that it can be extended by plugins: + * + * @example + * ```typescript + * declare module 'acorn' { + * interface NodeTypes { + * pluginName: FirstNode | SecondNode | ThirdNode | ... | LastNode + * } + * } + * ``` + */ +interface NodeTypes { + core: Statement | Expression | Declaration | ModuleDeclaration | Literal | Program | SwitchCase | CatchClause | Property | Super | SpreadElement | TemplateElement | AssignmentProperty | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | ClassBody | MethodDefinition | MetaProperty | ImportAttribute | ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier | AnonymousFunctionDeclaration | AnonymousClassDeclaration | PropertyDefinition | PrivateIdentifier | StaticBlock | VariableDeclarator +} + +export type AnyNode = NodeTypes[keyof NodeTypes] + +export function parse(input: string, options: Options): Program + +export function parseExpressionAt(input: string, pos: number, options: Options): Expression + +export function tokenizer(input: string, options: Options): { + getToken(): Token + [Symbol.iterator](): Iterator +} + +export type ecmaVersion = 3 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 2015 | 2016 | 2017 | 2018 | 2019 | 2020 | 2021 | 2022 | 2023 | 2024 | 2025 | 2026 | "latest" + +export interface Options { + /** + * `ecmaVersion` indicates the ECMAScript version to parse. Can be a + * number, either in year (`2022`) or plain version number (`6`) form, + * or `"latest"` (the latest the library supports). This influences + * support for strict mode, the set of reserved words, and support for + * new syntax features. + */ + ecmaVersion: ecmaVersion + + /** + * `sourceType` indicates the mode the code should be parsed in. + * Can be either `"script"` or `"module"`. This influences global + * strict mode and parsing of `import` and `export` declarations. + */ + sourceType?: "script" | "module" + + /** + * a callback that will be called when a semicolon is automatically inserted. + * @param lastTokEnd the position of the comma as an offset + * @param lastTokEndLoc location if {@link locations} is enabled + */ + onInsertedSemicolon?: (lastTokEnd: number, lastTokEndLoc?: Position) => void + + /** + * similar to `onInsertedSemicolon`, but for trailing commas + * @param lastTokEnd the position of the comma as an offset + * @param lastTokEndLoc location if `locations` is enabled + */ + onTrailingComma?: (lastTokEnd: number, lastTokEndLoc?: Position) => void + + /** + * By default, reserved words are only enforced if ecmaVersion >= 5. + * Set `allowReserved` to a boolean value to explicitly turn this on + * an off. When this option has the value "never", reserved words + * and keywords can also not be used as property names. + */ + allowReserved?: boolean | "never" + + /** + * When enabled, a return at the top level is not considered an error. + */ + allowReturnOutsideFunction?: boolean + + /** + * When enabled, import/export statements are not constrained to + * appearing at the top of the program, and an import.meta expression + * in a script isn't considered an error. + */ + allowImportExportEverywhere?: boolean + + /** + * By default, `await` identifiers are allowed to appear at the top-level scope only if {@link ecmaVersion} >= 2022. + * When enabled, await identifiers are allowed to appear at the top-level scope, + * but they are still not allowed in non-async functions. + */ + allowAwaitOutsideFunction?: boolean + + /** + * When enabled, super identifiers are not constrained to + * appearing in methods and do not raise an error when they appear elsewhere. + */ + allowSuperOutsideMethod?: boolean + + /** + * When enabled, hashbang directive in the beginning of file is + * allowed and treated as a line comment. Enabled by default when + * {@link ecmaVersion} >= 2023. + */ + allowHashBang?: boolean + + /** + * By default, the parser will verify that private properties are + * only used in places where they are valid and have been declared. + * Set this to false to turn such checks off. + */ + checkPrivateFields?: boolean + + /** + * When `locations` is on, `loc` properties holding objects with + * `start` and `end` properties as {@link Position} objects will be attached to the + * nodes. + */ + locations?: boolean + + /** + * a callback that will cause Acorn to call that export function with object in the same + * format as tokens returned from `tokenizer().getToken()`. Note + * that you are not allowed to call the parser from the + * callback—that will corrupt its internal state. + */ + onToken?: ((token: Token) => void) | Token[] + + + /** + * This takes a export function or an array. + * + * When a export function is passed, Acorn will call that export function with `(block, text, start, + * end)` parameters whenever a comment is skipped. `block` is a + * boolean indicating whether this is a block (`/* *\/`) comment, + * `text` is the content of the comment, and `start` and `end` are + * character offsets that denote the start and end of the comment. + * When the {@link locations} option is on, two more parameters are + * passed, the full locations of {@link Position} export type of the start and + * end of the comments. + * + * When a array is passed, each found comment of {@link Comment} export type is pushed to the array. + * + * Note that you are not allowed to call the + * parser from the callback—that will corrupt its internal state. + */ + onComment?: (( + isBlock: boolean, text: string, start: number, end: number, startLoc?: Position, + endLoc?: Position + ) => void) | Comment[] + + /** + * Nodes have their start and end characters offsets recorded in + * `start` and `end` properties (directly on the node, rather than + * the `loc` object, which holds line/column data. To also add a + * [semi-standardized][range] `range` property holding a `[start, + * end]` array with the same numbers, set the `ranges` option to + * `true`. + */ + ranges?: boolean + + /** + * It is possible to parse multiple files into a single AST by + * passing the tree produced by parsing the first file as + * `program` option in subsequent parses. This will add the + * toplevel forms of the parsed file to the `Program` (top) node + * of an existing parse tree. + */ + program?: Node + + /** + * When {@link locations} is on, you can pass this to record the source + * file in every node's `loc` object. + */ + sourceFile?: string + + /** + * This value, if given, is stored in every node, whether {@link locations} is on or off. + */ + directSourceFile?: string + + /** + * When enabled, parenthesized expressions are represented by + * (non-standard) ParenthesizedExpression nodes + */ + preserveParens?: boolean +} + +export class Parser { + options: Options + input: string + + protected constructor(options: Options, input: string, startPos?: number) + parse(): Program + + static parse(input: string, options: Options): Program + static parseExpressionAt(input: string, pos: number, options: Options): Expression + static tokenizer(input: string, options: Options): { + getToken(): Token + [Symbol.iterator](): Iterator + } + static extend(...plugins: ((BaseParser: typeof Parser) => typeof Parser)[]): typeof Parser +} + +export const defaultOptions: Options + +export function getLineInfo(input: string, offset: number): Position + +export class TokenType { + label: string + keyword: string | undefined +} + +export const tokTypes: { + num: TokenType + regexp: TokenType + string: TokenType + name: TokenType + privateId: TokenType + eof: TokenType + + bracketL: TokenType + bracketR: TokenType + braceL: TokenType + braceR: TokenType + parenL: TokenType + parenR: TokenType + comma: TokenType + semi: TokenType + colon: TokenType + dot: TokenType + question: TokenType + questionDot: TokenType + arrow: TokenType + template: TokenType + invalidTemplate: TokenType + ellipsis: TokenType + backQuote: TokenType + dollarBraceL: TokenType + + eq: TokenType + assign: TokenType + incDec: TokenType + prefix: TokenType + logicalOR: TokenType + logicalAND: TokenType + bitwiseOR: TokenType + bitwiseXOR: TokenType + bitwiseAND: TokenType + equality: TokenType + relational: TokenType + bitShift: TokenType + plusMin: TokenType + modulo: TokenType + star: TokenType + slash: TokenType + starstar: TokenType + coalesce: TokenType + + _break: TokenType + _case: TokenType + _catch: TokenType + _continue: TokenType + _debugger: TokenType + _default: TokenType + _do: TokenType + _else: TokenType + _finally: TokenType + _for: TokenType + _function: TokenType + _if: TokenType + _return: TokenType + _switch: TokenType + _throw: TokenType + _try: TokenType + _var: TokenType + _const: TokenType + _while: TokenType + _with: TokenType + _new: TokenType + _this: TokenType + _super: TokenType + _class: TokenType + _extends: TokenType + _export: TokenType + _import: TokenType + _null: TokenType + _true: TokenType + _false: TokenType + _in: TokenType + _instanceof: TokenType + _typeof: TokenType + _void: TokenType + _delete: TokenType +} + +export interface Comment { + type: "Line" | "Block" + value: string + start: number + end: number + loc?: SourceLocation + range?: [number, number] +} + +export class Token { + type: TokenType + start: number + end: number + loc?: SourceLocation + range?: [number, number] +} + +export const version: string diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/acorn/dist/acorn.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/acorn/dist/acorn.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f2ec5243bcb2625afcc11f4296b4250ca858c431 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/acorn/dist/acorn.d.ts @@ -0,0 +1,883 @@ +export interface Node { + start: number + end: number + type: string + range?: [number, number] + loc?: SourceLocation | null +} + +export interface SourceLocation { + source?: string | null + start: Position + end: Position +} + +export interface Position { + /** 1-based */ + line: number + /** 0-based */ + column: number +} + +export interface Identifier extends Node { + type: "Identifier" + name: string +} + +export interface Literal extends Node { + type: "Literal" + value?: string | boolean | null | number | RegExp | bigint + raw?: string + regex?: { + pattern: string + flags: string + } + bigint?: string +} + +export interface Program extends Node { + type: "Program" + body: Array + sourceType: "script" | "module" +} + +export interface Function extends Node { + id?: Identifier | null + params: Array + body: BlockStatement | Expression + generator: boolean + expression: boolean + async: boolean +} + +export interface ExpressionStatement extends Node { + type: "ExpressionStatement" + expression: Expression | Literal + directive?: string +} + +export interface BlockStatement extends Node { + type: "BlockStatement" + body: Array +} + +export interface EmptyStatement extends Node { + type: "EmptyStatement" +} + +export interface DebuggerStatement extends Node { + type: "DebuggerStatement" +} + +export interface WithStatement extends Node { + type: "WithStatement" + object: Expression + body: Statement +} + +export interface ReturnStatement extends Node { + type: "ReturnStatement" + argument?: Expression | null +} + +export interface LabeledStatement extends Node { + type: "LabeledStatement" + label: Identifier + body: Statement +} + +export interface BreakStatement extends Node { + type: "BreakStatement" + label?: Identifier | null +} + +export interface ContinueStatement extends Node { + type: "ContinueStatement" + label?: Identifier | null +} + +export interface IfStatement extends Node { + type: "IfStatement" + test: Expression + consequent: Statement + alternate?: Statement | null +} + +export interface SwitchStatement extends Node { + type: "SwitchStatement" + discriminant: Expression + cases: Array +} + +export interface SwitchCase extends Node { + type: "SwitchCase" + test?: Expression | null + consequent: Array +} + +export interface ThrowStatement extends Node { + type: "ThrowStatement" + argument: Expression +} + +export interface TryStatement extends Node { + type: "TryStatement" + block: BlockStatement + handler?: CatchClause | null + finalizer?: BlockStatement | null +} + +export interface CatchClause extends Node { + type: "CatchClause" + param?: Pattern | null + body: BlockStatement +} + +export interface WhileStatement extends Node { + type: "WhileStatement" + test: Expression + body: Statement +} + +export interface DoWhileStatement extends Node { + type: "DoWhileStatement" + body: Statement + test: Expression +} + +export interface ForStatement extends Node { + type: "ForStatement" + init?: VariableDeclaration | Expression | null + test?: Expression | null + update?: Expression | null + body: Statement +} + +export interface ForInStatement extends Node { + type: "ForInStatement" + left: VariableDeclaration | Pattern + right: Expression + body: Statement +} + +export interface FunctionDeclaration extends Function { + type: "FunctionDeclaration" + id: Identifier + body: BlockStatement +} + +export interface VariableDeclaration extends Node { + type: "VariableDeclaration" + declarations: Array + kind: "var" | "let" | "const" | "using" | "await using" +} + +export interface VariableDeclarator extends Node { + type: "VariableDeclarator" + id: Pattern + init?: Expression | null +} + +export interface ThisExpression extends Node { + type: "ThisExpression" +} + +export interface ArrayExpression extends Node { + type: "ArrayExpression" + elements: Array +} + +export interface ObjectExpression extends Node { + type: "ObjectExpression" + properties: Array +} + +export interface Property extends Node { + type: "Property" + key: Expression + value: Expression + kind: "init" | "get" | "set" + method: boolean + shorthand: boolean + computed: boolean +} + +export interface FunctionExpression extends Function { + type: "FunctionExpression" + body: BlockStatement +} + +export interface UnaryExpression extends Node { + type: "UnaryExpression" + operator: UnaryOperator + prefix: boolean + argument: Expression +} + +export type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete" + +export interface UpdateExpression extends Node { + type: "UpdateExpression" + operator: UpdateOperator + argument: Expression + prefix: boolean +} + +export type UpdateOperator = "++" | "--" + +export interface BinaryExpression extends Node { + type: "BinaryExpression" + operator: BinaryOperator + left: Expression | PrivateIdentifier + right: Expression +} + +export type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "|" | "^" | "&" | "in" | "instanceof" | "**" + +export interface AssignmentExpression extends Node { + type: "AssignmentExpression" + operator: AssignmentOperator + left: Pattern + right: Expression +} + +export type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "**=" | "||=" | "&&=" | "??=" + +export interface LogicalExpression extends Node { + type: "LogicalExpression" + operator: LogicalOperator + left: Expression + right: Expression +} + +export type LogicalOperator = "||" | "&&" | "??" + +export interface MemberExpression extends Node { + type: "MemberExpression" + object: Expression | Super + property: Expression | PrivateIdentifier + computed: boolean + optional: boolean +} + +export interface ConditionalExpression extends Node { + type: "ConditionalExpression" + test: Expression + alternate: Expression + consequent: Expression +} + +export interface CallExpression extends Node { + type: "CallExpression" + callee: Expression | Super + arguments: Array + optional: boolean +} + +export interface NewExpression extends Node { + type: "NewExpression" + callee: Expression + arguments: Array +} + +export interface SequenceExpression extends Node { + type: "SequenceExpression" + expressions: Array +} + +export interface ForOfStatement extends Node { + type: "ForOfStatement" + left: VariableDeclaration | Pattern + right: Expression + body: Statement + await: boolean +} + +export interface Super extends Node { + type: "Super" +} + +export interface SpreadElement extends Node { + type: "SpreadElement" + argument: Expression +} + +export interface ArrowFunctionExpression extends Function { + type: "ArrowFunctionExpression" +} + +export interface YieldExpression extends Node { + type: "YieldExpression" + argument?: Expression | null + delegate: boolean +} + +export interface TemplateLiteral extends Node { + type: "TemplateLiteral" + quasis: Array + expressions: Array +} + +export interface TaggedTemplateExpression extends Node { + type: "TaggedTemplateExpression" + tag: Expression + quasi: TemplateLiteral +} + +export interface TemplateElement extends Node { + type: "TemplateElement" + tail: boolean + value: { + cooked?: string | null + raw: string + } +} + +export interface AssignmentProperty extends Node { + type: "Property" + key: Expression + value: Pattern + kind: "init" + method: false + shorthand: boolean + computed: boolean +} + +export interface ObjectPattern extends Node { + type: "ObjectPattern" + properties: Array +} + +export interface ArrayPattern extends Node { + type: "ArrayPattern" + elements: Array +} + +export interface RestElement extends Node { + type: "RestElement" + argument: Pattern +} + +export interface AssignmentPattern extends Node { + type: "AssignmentPattern" + left: Pattern + right: Expression +} + +export interface Class extends Node { + id?: Identifier | null + superClass?: Expression | null + body: ClassBody +} + +export interface ClassBody extends Node { + type: "ClassBody" + body: Array +} + +export interface MethodDefinition extends Node { + type: "MethodDefinition" + key: Expression | PrivateIdentifier + value: FunctionExpression + kind: "constructor" | "method" | "get" | "set" + computed: boolean + static: boolean +} + +export interface ClassDeclaration extends Class { + type: "ClassDeclaration" + id: Identifier +} + +export interface ClassExpression extends Class { + type: "ClassExpression" +} + +export interface MetaProperty extends Node { + type: "MetaProperty" + meta: Identifier + property: Identifier +} + +export interface ImportDeclaration extends Node { + type: "ImportDeclaration" + specifiers: Array + source: Literal + attributes: Array +} + +export interface ImportSpecifier extends Node { + type: "ImportSpecifier" + imported: Identifier | Literal + local: Identifier +} + +export interface ImportDefaultSpecifier extends Node { + type: "ImportDefaultSpecifier" + local: Identifier +} + +export interface ImportNamespaceSpecifier extends Node { + type: "ImportNamespaceSpecifier" + local: Identifier +} + +export interface ImportAttribute extends Node { + type: "ImportAttribute" + key: Identifier | Literal + value: Literal +} + +export interface ExportNamedDeclaration extends Node { + type: "ExportNamedDeclaration" + declaration?: Declaration | null + specifiers: Array + source?: Literal | null + attributes: Array +} + +export interface ExportSpecifier extends Node { + type: "ExportSpecifier" + exported: Identifier | Literal + local: Identifier | Literal +} + +export interface AnonymousFunctionDeclaration extends Function { + type: "FunctionDeclaration" + id: null + body: BlockStatement +} + +export interface AnonymousClassDeclaration extends Class { + type: "ClassDeclaration" + id: null +} + +export interface ExportDefaultDeclaration extends Node { + type: "ExportDefaultDeclaration" + declaration: AnonymousFunctionDeclaration | FunctionDeclaration | AnonymousClassDeclaration | ClassDeclaration | Expression +} + +export interface ExportAllDeclaration extends Node { + type: "ExportAllDeclaration" + source: Literal + exported?: Identifier | Literal | null + attributes: Array +} + +export interface AwaitExpression extends Node { + type: "AwaitExpression" + argument: Expression +} + +export interface ChainExpression extends Node { + type: "ChainExpression" + expression: MemberExpression | CallExpression +} + +export interface ImportExpression extends Node { + type: "ImportExpression" + source: Expression + options: Expression | null +} + +export interface ParenthesizedExpression extends Node { + type: "ParenthesizedExpression" + expression: Expression +} + +export interface PropertyDefinition extends Node { + type: "PropertyDefinition" + key: Expression | PrivateIdentifier + value?: Expression | null + computed: boolean + static: boolean +} + +export interface PrivateIdentifier extends Node { + type: "PrivateIdentifier" + name: string +} + +export interface StaticBlock extends Node { + type: "StaticBlock" + body: Array +} + +export type Statement = +| ExpressionStatement +| BlockStatement +| EmptyStatement +| DebuggerStatement +| WithStatement +| ReturnStatement +| LabeledStatement +| BreakStatement +| ContinueStatement +| IfStatement +| SwitchStatement +| ThrowStatement +| TryStatement +| WhileStatement +| DoWhileStatement +| ForStatement +| ForInStatement +| ForOfStatement +| Declaration + +export type Declaration = +| FunctionDeclaration +| VariableDeclaration +| ClassDeclaration + +export type Expression = +| Identifier +| Literal +| ThisExpression +| ArrayExpression +| ObjectExpression +| FunctionExpression +| UnaryExpression +| UpdateExpression +| BinaryExpression +| AssignmentExpression +| LogicalExpression +| MemberExpression +| ConditionalExpression +| CallExpression +| NewExpression +| SequenceExpression +| ArrowFunctionExpression +| YieldExpression +| TemplateLiteral +| TaggedTemplateExpression +| ClassExpression +| MetaProperty +| AwaitExpression +| ChainExpression +| ImportExpression +| ParenthesizedExpression + +export type Pattern = +| Identifier +| MemberExpression +| ObjectPattern +| ArrayPattern +| RestElement +| AssignmentPattern + +export type ModuleDeclaration = +| ImportDeclaration +| ExportNamedDeclaration +| ExportDefaultDeclaration +| ExportAllDeclaration + +/** + * This interface is only used for defining {@link AnyNode}. + * It exists so that it can be extended by plugins: + * + * @example + * ```typescript + * declare module 'acorn' { + * interface NodeTypes { + * pluginName: FirstNode | SecondNode | ThirdNode | ... | LastNode + * } + * } + * ``` + */ +interface NodeTypes { + core: Statement | Expression | Declaration | ModuleDeclaration | Literal | Program | SwitchCase | CatchClause | Property | Super | SpreadElement | TemplateElement | AssignmentProperty | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | ClassBody | MethodDefinition | MetaProperty | ImportAttribute | ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier | AnonymousFunctionDeclaration | AnonymousClassDeclaration | PropertyDefinition | PrivateIdentifier | StaticBlock | VariableDeclarator +} + +export type AnyNode = NodeTypes[keyof NodeTypes] + +export function parse(input: string, options: Options): Program + +export function parseExpressionAt(input: string, pos: number, options: Options): Expression + +export function tokenizer(input: string, options: Options): { + getToken(): Token + [Symbol.iterator](): Iterator +} + +export type ecmaVersion = 3 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 2015 | 2016 | 2017 | 2018 | 2019 | 2020 | 2021 | 2022 | 2023 | 2024 | 2025 | 2026 | "latest" + +export interface Options { + /** + * `ecmaVersion` indicates the ECMAScript version to parse. Can be a + * number, either in year (`2022`) or plain version number (`6`) form, + * or `"latest"` (the latest the library supports). This influences + * support for strict mode, the set of reserved words, and support for + * new syntax features. + */ + ecmaVersion: ecmaVersion + + /** + * `sourceType` indicates the mode the code should be parsed in. + * Can be either `"script"` or `"module"`. This influences global + * strict mode and parsing of `import` and `export` declarations. + */ + sourceType?: "script" | "module" + + /** + * a callback that will be called when a semicolon is automatically inserted. + * @param lastTokEnd the position of the comma as an offset + * @param lastTokEndLoc location if {@link locations} is enabled + */ + onInsertedSemicolon?: (lastTokEnd: number, lastTokEndLoc?: Position) => void + + /** + * similar to `onInsertedSemicolon`, but for trailing commas + * @param lastTokEnd the position of the comma as an offset + * @param lastTokEndLoc location if `locations` is enabled + */ + onTrailingComma?: (lastTokEnd: number, lastTokEndLoc?: Position) => void + + /** + * By default, reserved words are only enforced if ecmaVersion >= 5. + * Set `allowReserved` to a boolean value to explicitly turn this on + * an off. When this option has the value "never", reserved words + * and keywords can also not be used as property names. + */ + allowReserved?: boolean | "never" + + /** + * When enabled, a return at the top level is not considered an error. + */ + allowReturnOutsideFunction?: boolean + + /** + * When enabled, import/export statements are not constrained to + * appearing at the top of the program, and an import.meta expression + * in a script isn't considered an error. + */ + allowImportExportEverywhere?: boolean + + /** + * By default, `await` identifiers are allowed to appear at the top-level scope only if {@link ecmaVersion} >= 2022. + * When enabled, await identifiers are allowed to appear at the top-level scope, + * but they are still not allowed in non-async functions. + */ + allowAwaitOutsideFunction?: boolean + + /** + * When enabled, super identifiers are not constrained to + * appearing in methods and do not raise an error when they appear elsewhere. + */ + allowSuperOutsideMethod?: boolean + + /** + * When enabled, hashbang directive in the beginning of file is + * allowed and treated as a line comment. Enabled by default when + * {@link ecmaVersion} >= 2023. + */ + allowHashBang?: boolean + + /** + * By default, the parser will verify that private properties are + * only used in places where they are valid and have been declared. + * Set this to false to turn such checks off. + */ + checkPrivateFields?: boolean + + /** + * When `locations` is on, `loc` properties holding objects with + * `start` and `end` properties as {@link Position} objects will be attached to the + * nodes. + */ + locations?: boolean + + /** + * a callback that will cause Acorn to call that export function with object in the same + * format as tokens returned from `tokenizer().getToken()`. Note + * that you are not allowed to call the parser from the + * callback—that will corrupt its internal state. + */ + onToken?: ((token: Token) => void) | Token[] + + + /** + * This takes a export function or an array. + * + * When a export function is passed, Acorn will call that export function with `(block, text, start, + * end)` parameters whenever a comment is skipped. `block` is a + * boolean indicating whether this is a block (`/* *\/`) comment, + * `text` is the content of the comment, and `start` and `end` are + * character offsets that denote the start and end of the comment. + * When the {@link locations} option is on, two more parameters are + * passed, the full locations of {@link Position} export type of the start and + * end of the comments. + * + * When a array is passed, each found comment of {@link Comment} export type is pushed to the array. + * + * Note that you are not allowed to call the + * parser from the callback—that will corrupt its internal state. + */ + onComment?: (( + isBlock: boolean, text: string, start: number, end: number, startLoc?: Position, + endLoc?: Position + ) => void) | Comment[] + + /** + * Nodes have their start and end characters offsets recorded in + * `start` and `end` properties (directly on the node, rather than + * the `loc` object, which holds line/column data. To also add a + * [semi-standardized][range] `range` property holding a `[start, + * end]` array with the same numbers, set the `ranges` option to + * `true`. + */ + ranges?: boolean + + /** + * It is possible to parse multiple files into a single AST by + * passing the tree produced by parsing the first file as + * `program` option in subsequent parses. This will add the + * toplevel forms of the parsed file to the `Program` (top) node + * of an existing parse tree. + */ + program?: Node + + /** + * When {@link locations} is on, you can pass this to record the source + * file in every node's `loc` object. + */ + sourceFile?: string + + /** + * This value, if given, is stored in every node, whether {@link locations} is on or off. + */ + directSourceFile?: string + + /** + * When enabled, parenthesized expressions are represented by + * (non-standard) ParenthesizedExpression nodes + */ + preserveParens?: boolean +} + +export class Parser { + options: Options + input: string + + protected constructor(options: Options, input: string, startPos?: number) + parse(): Program + + static parse(input: string, options: Options): Program + static parseExpressionAt(input: string, pos: number, options: Options): Expression + static tokenizer(input: string, options: Options): { + getToken(): Token + [Symbol.iterator](): Iterator + } + static extend(...plugins: ((BaseParser: typeof Parser) => typeof Parser)[]): typeof Parser +} + +export const defaultOptions: Options + +export function getLineInfo(input: string, offset: number): Position + +export class TokenType { + label: string + keyword: string | undefined +} + +export const tokTypes: { + num: TokenType + regexp: TokenType + string: TokenType + name: TokenType + privateId: TokenType + eof: TokenType + + bracketL: TokenType + bracketR: TokenType + braceL: TokenType + braceR: TokenType + parenL: TokenType + parenR: TokenType + comma: TokenType + semi: TokenType + colon: TokenType + dot: TokenType + question: TokenType + questionDot: TokenType + arrow: TokenType + template: TokenType + invalidTemplate: TokenType + ellipsis: TokenType + backQuote: TokenType + dollarBraceL: TokenType + + eq: TokenType + assign: TokenType + incDec: TokenType + prefix: TokenType + logicalOR: TokenType + logicalAND: TokenType + bitwiseOR: TokenType + bitwiseXOR: TokenType + bitwiseAND: TokenType + equality: TokenType + relational: TokenType + bitShift: TokenType + plusMin: TokenType + modulo: TokenType + star: TokenType + slash: TokenType + starstar: TokenType + coalesce: TokenType + + _break: TokenType + _case: TokenType + _catch: TokenType + _continue: TokenType + _debugger: TokenType + _default: TokenType + _do: TokenType + _else: TokenType + _finally: TokenType + _for: TokenType + _function: TokenType + _if: TokenType + _return: TokenType + _switch: TokenType + _throw: TokenType + _try: TokenType + _var: TokenType + _const: TokenType + _while: TokenType + _with: TokenType + _new: TokenType + _this: TokenType + _super: TokenType + _class: TokenType + _extends: TokenType + _export: TokenType + _import: TokenType + _null: TokenType + _true: TokenType + _false: TokenType + _in: TokenType + _instanceof: TokenType + _typeof: TokenType + _void: TokenType + _delete: TokenType +} + +export interface Comment { + type: "Line" | "Block" + value: string + start: number + end: number + loc?: SourceLocation + range?: [number, number] +} + +export class Token { + type: TokenType + start: number + end: number + loc?: SourceLocation + range?: [number, number] +} + +export const version: string diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/acorn/dist/acorn.js b/novas/novacore-zephyr/groq-code-cli/node_modules/acorn/dist/acorn.js new file mode 100644 index 0000000000000000000000000000000000000000..cb5628bf83cf0bcb63514b797a38e0442c383ea8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/acorn/dist/acorn.js @@ -0,0 +1,6262 @@ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : + typeof define === 'function' && define.amd ? define(['exports'], factory) : + (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.acorn = {})); +})(this, (function (exports) { 'use strict'; + + // This file was generated. Do not modify manually! + var astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 7, 9, 32, 4, 318, 1, 80, 3, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 68, 8, 2, 0, 3, 0, 2, 3, 2, 4, 2, 0, 15, 1, 83, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 7, 19, 58, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 343, 9, 54, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 10, 5350, 0, 7, 14, 11465, 27, 2343, 9, 87, 9, 39, 4, 60, 6, 26, 9, 535, 9, 470, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4178, 9, 519, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 245, 1, 2, 9, 726, 6, 110, 6, 6, 9, 4759, 9, 787719, 239]; + + // This file was generated. Do not modify manually! + var astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 4, 51, 13, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 39, 27, 10, 22, 251, 41, 7, 1, 17, 2, 60, 28, 11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 20, 1, 64, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 31, 9, 2, 0, 3, 0, 2, 37, 2, 0, 26, 0, 2, 0, 45, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 200, 32, 32, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1071, 18, 5, 26, 3994, 6, 582, 6842, 29, 1763, 568, 8, 30, 18, 78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 433, 44, 212, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 1237, 42, 9, 8936, 3, 2, 6, 2, 1, 2, 290, 16, 0, 30, 2, 3, 0, 15, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 7, 5, 262, 61, 147, 44, 11, 6, 17, 0, 322, 29, 19, 43, 485, 27, 229, 29, 3, 0, 496, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4153, 7, 221, 3, 5761, 15, 7472, 16, 621, 2467, 541, 1507, 4938, 6, 4191]; + + // This file was generated. Do not modify manually! + var nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0897-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0cf3\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u180f-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf-\u1ace\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dff\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\u30fb\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f\uff65"; + + // This file was generated. Do not modify manually! + var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088e\u08a0-\u08c9\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5d\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c8a\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7cd\ua7d0\ua7d1\ua7d3\ua7d5-\ua7dc\ua7f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc"; + + // These are a run-length and offset encoded representation of the + // >0xffff code points that are a valid part of identifiers. The + // offset starts at 0x10000, and each pair of numbers represents an + // offset to the next range, and then a size of the range. + + // Reserved word lists for various dialects of the language + + var reservedWords = { + 3: "abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile", + 5: "class enum extends super const export import", + 6: "enum", + strict: "implements interface let package private protected public static yield", + strictBind: "eval arguments" + }; + + // And the keywords + + var ecma5AndLessKeywords = "break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this"; + + var keywords$1 = { + 5: ecma5AndLessKeywords, + "5module": ecma5AndLessKeywords + " export import", + 6: ecma5AndLessKeywords + " const class extends export import super" + }; + + var keywordRelationalOperator = /^in(stanceof)?$/; + + // ## Character categories + + var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]"); + var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]"); + + // This has a complexity linear to the value of the code. The + // assumption is that looking up astral identifier characters is + // rare. + function isInAstralSet(code, set) { + var pos = 0x10000; + for (var i = 0; i < set.length; i += 2) { + pos += set[i]; + if (pos > code) { return false } + pos += set[i + 1]; + if (pos >= code) { return true } + } + return false + } + + // Test whether a given character code starts an identifier. + + function isIdentifierStart(code, astral) { + if (code < 65) { return code === 36 } + if (code < 91) { return true } + if (code < 97) { return code === 95 } + if (code < 123) { return true } + if (code <= 0xffff) { return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code)) } + if (astral === false) { return false } + return isInAstralSet(code, astralIdentifierStartCodes) + } + + // Test whether a given character is part of an identifier. + + function isIdentifierChar(code, astral) { + if (code < 48) { return code === 36 } + if (code < 58) { return true } + if (code < 65) { return false } + if (code < 91) { return true } + if (code < 97) { return code === 95 } + if (code < 123) { return true } + if (code <= 0xffff) { return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code)) } + if (astral === false) { return false } + return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes) + } + + // ## Token types + + // The assignment of fine-grained, information-carrying type objects + // allows the tokenizer to store the information it has about a + // token in a way that is very cheap for the parser to look up. + + // All token type variables start with an underscore, to make them + // easy to recognize. + + // The `beforeExpr` property is used to disambiguate between regular + // expressions and divisions. It is set on all token types that can + // be followed by an expression (thus, a slash after them would be a + // regular expression). + // + // The `startsExpr` property is used to check if the token ends a + // `yield` expression. It is set on all token types that either can + // directly start an expression (like a quotation mark) or can + // continue an expression (like the body of a string). + // + // `isLoop` marks a keyword as starting a loop, which is important + // to know when parsing a label, in order to allow or disallow + // continue jumps to that label. + + var TokenType = function TokenType(label, conf) { + if ( conf === void 0 ) conf = {}; + + this.label = label; + this.keyword = conf.keyword; + this.beforeExpr = !!conf.beforeExpr; + this.startsExpr = !!conf.startsExpr; + this.isLoop = !!conf.isLoop; + this.isAssign = !!conf.isAssign; + this.prefix = !!conf.prefix; + this.postfix = !!conf.postfix; + this.binop = conf.binop || null; + this.updateContext = null; + }; + + function binop(name, prec) { + return new TokenType(name, {beforeExpr: true, binop: prec}) + } + var beforeExpr = {beforeExpr: true}, startsExpr = {startsExpr: true}; + + // Map keyword names to token types. + + var keywords = {}; + + // Succinct definitions of keyword token types + function kw(name, options) { + if ( options === void 0 ) options = {}; + + options.keyword = name; + return keywords[name] = new TokenType(name, options) + } + + var types$1 = { + num: new TokenType("num", startsExpr), + regexp: new TokenType("regexp", startsExpr), + string: new TokenType("string", startsExpr), + name: new TokenType("name", startsExpr), + privateId: new TokenType("privateId", startsExpr), + eof: new TokenType("eof"), + + // Punctuation token types. + bracketL: new TokenType("[", {beforeExpr: true, startsExpr: true}), + bracketR: new TokenType("]"), + braceL: new TokenType("{", {beforeExpr: true, startsExpr: true}), + braceR: new TokenType("}"), + parenL: new TokenType("(", {beforeExpr: true, startsExpr: true}), + parenR: new TokenType(")"), + comma: new TokenType(",", beforeExpr), + semi: new TokenType(";", beforeExpr), + colon: new TokenType(":", beforeExpr), + dot: new TokenType("."), + question: new TokenType("?", beforeExpr), + questionDot: new TokenType("?."), + arrow: new TokenType("=>", beforeExpr), + template: new TokenType("template"), + invalidTemplate: new TokenType("invalidTemplate"), + ellipsis: new TokenType("...", beforeExpr), + backQuote: new TokenType("`", startsExpr), + dollarBraceL: new TokenType("${", {beforeExpr: true, startsExpr: true}), + + // Operators. These carry several kinds of properties to help the + // parser use them properly (the presence of these properties is + // what categorizes them as operators). + // + // `binop`, when present, specifies that this operator is a binary + // operator, and will refer to its precedence. + // + // `prefix` and `postfix` mark the operator as a prefix or postfix + // unary operator. + // + // `isAssign` marks all of `=`, `+=`, `-=` etcetera, which act as + // binary operators with a very low precedence, that should result + // in AssignmentExpression nodes. + + eq: new TokenType("=", {beforeExpr: true, isAssign: true}), + assign: new TokenType("_=", {beforeExpr: true, isAssign: true}), + incDec: new TokenType("++/--", {prefix: true, postfix: true, startsExpr: true}), + prefix: new TokenType("!/~", {beforeExpr: true, prefix: true, startsExpr: true}), + logicalOR: binop("||", 1), + logicalAND: binop("&&", 2), + bitwiseOR: binop("|", 3), + bitwiseXOR: binop("^", 4), + bitwiseAND: binop("&", 5), + equality: binop("==/!=/===/!==", 6), + relational: binop("/<=/>=", 7), + bitShift: binop("<>/>>>", 8), + plusMin: new TokenType("+/-", {beforeExpr: true, binop: 9, prefix: true, startsExpr: true}), + modulo: binop("%", 10), + star: binop("*", 10), + slash: binop("/", 10), + starstar: new TokenType("**", {beforeExpr: true}), + coalesce: binop("??", 1), + + // Keyword token types. + _break: kw("break"), + _case: kw("case", beforeExpr), + _catch: kw("catch"), + _continue: kw("continue"), + _debugger: kw("debugger"), + _default: kw("default", beforeExpr), + _do: kw("do", {isLoop: true, beforeExpr: true}), + _else: kw("else", beforeExpr), + _finally: kw("finally"), + _for: kw("for", {isLoop: true}), + _function: kw("function", startsExpr), + _if: kw("if"), + _return: kw("return", beforeExpr), + _switch: kw("switch"), + _throw: kw("throw", beforeExpr), + _try: kw("try"), + _var: kw("var"), + _const: kw("const"), + _while: kw("while", {isLoop: true}), + _with: kw("with"), + _new: kw("new", {beforeExpr: true, startsExpr: true}), + _this: kw("this", startsExpr), + _super: kw("super", startsExpr), + _class: kw("class", startsExpr), + _extends: kw("extends", beforeExpr), + _export: kw("export"), + _import: kw("import", startsExpr), + _null: kw("null", startsExpr), + _true: kw("true", startsExpr), + _false: kw("false", startsExpr), + _in: kw("in", {beforeExpr: true, binop: 7}), + _instanceof: kw("instanceof", {beforeExpr: true, binop: 7}), + _typeof: kw("typeof", {beforeExpr: true, prefix: true, startsExpr: true}), + _void: kw("void", {beforeExpr: true, prefix: true, startsExpr: true}), + _delete: kw("delete", {beforeExpr: true, prefix: true, startsExpr: true}) + }; + + // Matches a whole line break (where CRLF is considered a single + // line break). Used to count lines. + + var lineBreak = /\r\n?|\n|\u2028|\u2029/; + var lineBreakG = new RegExp(lineBreak.source, "g"); + + function isNewLine(code) { + return code === 10 || code === 13 || code === 0x2028 || code === 0x2029 + } + + function nextLineBreak(code, from, end) { + if ( end === void 0 ) end = code.length; + + for (var i = from; i < end; i++) { + var next = code.charCodeAt(i); + if (isNewLine(next)) + { return i < end - 1 && next === 13 && code.charCodeAt(i + 1) === 10 ? i + 2 : i + 1 } + } + return -1 + } + + var nonASCIIwhitespace = /[\u1680\u2000-\u200a\u202f\u205f\u3000\ufeff]/; + + var skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g; + + var ref = Object.prototype; + var hasOwnProperty = ref.hasOwnProperty; + var toString = ref.toString; + + var hasOwn = Object.hasOwn || (function (obj, propName) { return ( + hasOwnProperty.call(obj, propName) + ); }); + + var isArray = Array.isArray || (function (obj) { return ( + toString.call(obj) === "[object Array]" + ); }); + + var regexpCache = Object.create(null); + + function wordsRegexp(words) { + return regexpCache[words] || (regexpCache[words] = new RegExp("^(?:" + words.replace(/ /g, "|") + ")$")) + } + + function codePointToString(code) { + // UTF-16 Decoding + if (code <= 0xFFFF) { return String.fromCharCode(code) } + code -= 0x10000; + return String.fromCharCode((code >> 10) + 0xD800, (code & 1023) + 0xDC00) + } + + var loneSurrogate = /(?:[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])/; + + // These are used when `options.locations` is on, for the + // `startLoc` and `endLoc` properties. + + var Position = function Position(line, col) { + this.line = line; + this.column = col; + }; + + Position.prototype.offset = function offset (n) { + return new Position(this.line, this.column + n) + }; + + var SourceLocation = function SourceLocation(p, start, end) { + this.start = start; + this.end = end; + if (p.sourceFile !== null) { this.source = p.sourceFile; } + }; + + // The `getLineInfo` function is mostly useful when the + // `locations` option is off (for performance reasons) and you + // want to find the line/column position for a given character + // offset. `input` should be the code string that the offset refers + // into. + + function getLineInfo(input, offset) { + for (var line = 1, cur = 0;;) { + var nextBreak = nextLineBreak(input, cur, offset); + if (nextBreak < 0) { return new Position(line, offset - cur) } + ++line; + cur = nextBreak; + } + } + + // A second argument must be given to configure the parser process. + // These options are recognized (only `ecmaVersion` is required): + + var defaultOptions = { + // `ecmaVersion` indicates the ECMAScript version to parse. Must be + // either 3, 5, 6 (or 2015), 7 (2016), 8 (2017), 9 (2018), 10 + // (2019), 11 (2020), 12 (2021), 13 (2022), 14 (2023), or `"latest"` + // (the latest version the library supports). This influences + // support for strict mode, the set of reserved words, and support + // for new syntax features. + ecmaVersion: null, + // `sourceType` indicates the mode the code should be parsed in. + // Can be either `"script"` or `"module"`. This influences global + // strict mode and parsing of `import` and `export` declarations. + sourceType: "script", + // `onInsertedSemicolon` can be a callback that will be called when + // a semicolon is automatically inserted. It will be passed the + // position of the inserted semicolon as an offset, and if + // `locations` is enabled, it is given the location as a `{line, + // column}` object as second argument. + onInsertedSemicolon: null, + // `onTrailingComma` is similar to `onInsertedSemicolon`, but for + // trailing commas. + onTrailingComma: null, + // By default, reserved words are only enforced if ecmaVersion >= 5. + // Set `allowReserved` to a boolean value to explicitly turn this on + // an off. When this option has the value "never", reserved words + // and keywords can also not be used as property names. + allowReserved: null, + // When enabled, a return at the top level is not considered an + // error. + allowReturnOutsideFunction: false, + // When enabled, import/export statements are not constrained to + // appearing at the top of the program, and an import.meta expression + // in a script isn't considered an error. + allowImportExportEverywhere: false, + // By default, await identifiers are allowed to appear at the top-level scope only if ecmaVersion >= 2022. + // When enabled, await identifiers are allowed to appear at the top-level scope, + // but they are still not allowed in non-async functions. + allowAwaitOutsideFunction: null, + // When enabled, super identifiers are not constrained to + // appearing in methods and do not raise an error when they appear elsewhere. + allowSuperOutsideMethod: null, + // When enabled, hashbang directive in the beginning of file is + // allowed and treated as a line comment. Enabled by default when + // `ecmaVersion` >= 2023. + allowHashBang: false, + // By default, the parser will verify that private properties are + // only used in places where they are valid and have been declared. + // Set this to false to turn such checks off. + checkPrivateFields: true, + // When `locations` is on, `loc` properties holding objects with + // `start` and `end` properties in `{line, column}` form (with + // line being 1-based and column 0-based) will be attached to the + // nodes. + locations: false, + // A function can be passed as `onToken` option, which will + // cause Acorn to call that function with object in the same + // format as tokens returned from `tokenizer().getToken()`. Note + // that you are not allowed to call the parser from the + // callback—that will corrupt its internal state. + onToken: null, + // A function can be passed as `onComment` option, which will + // cause Acorn to call that function with `(block, text, start, + // end)` parameters whenever a comment is skipped. `block` is a + // boolean indicating whether this is a block (`/* */`) comment, + // `text` is the content of the comment, and `start` and `end` are + // character offsets that denote the start and end of the comment. + // When the `locations` option is on, two more parameters are + // passed, the full `{line, column}` locations of the start and + // end of the comments. Note that you are not allowed to call the + // parser from the callback—that will corrupt its internal state. + // When this option has an array as value, objects representing the + // comments are pushed to it. + onComment: null, + // Nodes have their start and end characters offsets recorded in + // `start` and `end` properties (directly on the node, rather than + // the `loc` object, which holds line/column data. To also add a + // [semi-standardized][range] `range` property holding a `[start, + // end]` array with the same numbers, set the `ranges` option to + // `true`. + // + // [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678 + ranges: false, + // It is possible to parse multiple files into a single AST by + // passing the tree produced by parsing the first file as + // `program` option in subsequent parses. This will add the + // toplevel forms of the parsed file to the `Program` (top) node + // of an existing parse tree. + program: null, + // When `locations` is on, you can pass this to record the source + // file in every node's `loc` object. + sourceFile: null, + // This value, if given, is stored in every node, whether + // `locations` is on or off. + directSourceFile: null, + // When enabled, parenthesized expressions are represented by + // (non-standard) ParenthesizedExpression nodes + preserveParens: false + }; + + // Interpret and default an options object + + var warnedAboutEcmaVersion = false; + + function getOptions(opts) { + var options = {}; + + for (var opt in defaultOptions) + { options[opt] = opts && hasOwn(opts, opt) ? opts[opt] : defaultOptions[opt]; } + + if (options.ecmaVersion === "latest") { + options.ecmaVersion = 1e8; + } else if (options.ecmaVersion == null) { + if (!warnedAboutEcmaVersion && typeof console === "object" && console.warn) { + warnedAboutEcmaVersion = true; + console.warn("Since Acorn 8.0.0, options.ecmaVersion is required.\nDefaulting to 2020, but this will stop working in the future."); + } + options.ecmaVersion = 11; + } else if (options.ecmaVersion >= 2015) { + options.ecmaVersion -= 2009; + } + + if (options.allowReserved == null) + { options.allowReserved = options.ecmaVersion < 5; } + + if (!opts || opts.allowHashBang == null) + { options.allowHashBang = options.ecmaVersion >= 14; } + + if (isArray(options.onToken)) { + var tokens = options.onToken; + options.onToken = function (token) { return tokens.push(token); }; + } + if (isArray(options.onComment)) + { options.onComment = pushComment(options, options.onComment); } + + return options + } + + function pushComment(options, array) { + return function(block, text, start, end, startLoc, endLoc) { + var comment = { + type: block ? "Block" : "Line", + value: text, + start: start, + end: end + }; + if (options.locations) + { comment.loc = new SourceLocation(this, startLoc, endLoc); } + if (options.ranges) + { comment.range = [start, end]; } + array.push(comment); + } + } + + // Each scope gets a bitset that may contain these flags + var + SCOPE_TOP = 1, + SCOPE_FUNCTION = 2, + SCOPE_ASYNC = 4, + SCOPE_GENERATOR = 8, + SCOPE_ARROW = 16, + SCOPE_SIMPLE_CATCH = 32, + SCOPE_SUPER = 64, + SCOPE_DIRECT_SUPER = 128, + SCOPE_CLASS_STATIC_BLOCK = 256, + SCOPE_CLASS_FIELD_INIT = 512, + SCOPE_VAR = SCOPE_TOP | SCOPE_FUNCTION | SCOPE_CLASS_STATIC_BLOCK; + + function functionFlags(async, generator) { + return SCOPE_FUNCTION | (async ? SCOPE_ASYNC : 0) | (generator ? SCOPE_GENERATOR : 0) + } + + // Used in checkLVal* and declareName to determine the type of a binding + var + BIND_NONE = 0, // Not a binding + BIND_VAR = 1, // Var-style binding + BIND_LEXICAL = 2, // Let- or const-style binding + BIND_FUNCTION = 3, // Function declaration + BIND_SIMPLE_CATCH = 4, // Simple (identifier pattern) catch binding + BIND_OUTSIDE = 5; // Special case for function names as bound inside the function + + var Parser = function Parser(options, input, startPos) { + this.options = options = getOptions(options); + this.sourceFile = options.sourceFile; + this.keywords = wordsRegexp(keywords$1[options.ecmaVersion >= 6 ? 6 : options.sourceType === "module" ? "5module" : 5]); + var reserved = ""; + if (options.allowReserved !== true) { + reserved = reservedWords[options.ecmaVersion >= 6 ? 6 : options.ecmaVersion === 5 ? 5 : 3]; + if (options.sourceType === "module") { reserved += " await"; } + } + this.reservedWords = wordsRegexp(reserved); + var reservedStrict = (reserved ? reserved + " " : "") + reservedWords.strict; + this.reservedWordsStrict = wordsRegexp(reservedStrict); + this.reservedWordsStrictBind = wordsRegexp(reservedStrict + " " + reservedWords.strictBind); + this.input = String(input); + + // Used to signal to callers of `readWord1` whether the word + // contained any escape sequences. This is needed because words with + // escape sequences must not be interpreted as keywords. + this.containsEsc = false; + + // Set up token state + + // The current position of the tokenizer in the input. + if (startPos) { + this.pos = startPos; + this.lineStart = this.input.lastIndexOf("\n", startPos - 1) + 1; + this.curLine = this.input.slice(0, this.lineStart).split(lineBreak).length; + } else { + this.pos = this.lineStart = 0; + this.curLine = 1; + } + + // Properties of the current token: + // Its type + this.type = types$1.eof; + // For tokens that include more information than their type, the value + this.value = null; + // Its start and end offset + this.start = this.end = this.pos; + // And, if locations are used, the {line, column} object + // corresponding to those offsets + this.startLoc = this.endLoc = this.curPosition(); + + // Position information for the previous token + this.lastTokEndLoc = this.lastTokStartLoc = null; + this.lastTokStart = this.lastTokEnd = this.pos; + + // The context stack is used to superficially track syntactic + // context to predict whether a regular expression is allowed in a + // given position. + this.context = this.initialContext(); + this.exprAllowed = true; + + // Figure out if it's a module code. + this.inModule = options.sourceType === "module"; + this.strict = this.inModule || this.strictDirective(this.pos); + + // Used to signify the start of a potential arrow function + this.potentialArrowAt = -1; + this.potentialArrowInForAwait = false; + + // Positions to delayed-check that yield/await does not exist in default parameters. + this.yieldPos = this.awaitPos = this.awaitIdentPos = 0; + // Labels in scope. + this.labels = []; + // Thus-far undefined exports. + this.undefinedExports = Object.create(null); + + // If enabled, skip leading hashbang line. + if (this.pos === 0 && options.allowHashBang && this.input.slice(0, 2) === "#!") + { this.skipLineComment(2); } + + // Scope tracking for duplicate variable names (see scope.js) + this.scopeStack = []; + this.enterScope(SCOPE_TOP); + + // For RegExp validation + this.regexpState = null; + + // The stack of private names. + // Each element has two properties: 'declared' and 'used'. + // When it exited from the outermost class definition, all used private names must be declared. + this.privateNameStack = []; + }; + + var prototypeAccessors = { inFunction: { configurable: true },inGenerator: { configurable: true },inAsync: { configurable: true },canAwait: { configurable: true },allowSuper: { configurable: true },allowDirectSuper: { configurable: true },treatFunctionsAsVar: { configurable: true },allowNewDotTarget: { configurable: true },inClassStaticBlock: { configurable: true } }; + + Parser.prototype.parse = function parse () { + var node = this.options.program || this.startNode(); + this.nextToken(); + return this.parseTopLevel(node) + }; + + prototypeAccessors.inFunction.get = function () { return (this.currentVarScope().flags & SCOPE_FUNCTION) > 0 }; + + prototypeAccessors.inGenerator.get = function () { return (this.currentVarScope().flags & SCOPE_GENERATOR) > 0 }; + + prototypeAccessors.inAsync.get = function () { return (this.currentVarScope().flags & SCOPE_ASYNC) > 0 }; + + prototypeAccessors.canAwait.get = function () { + for (var i = this.scopeStack.length - 1; i >= 0; i--) { + var ref = this.scopeStack[i]; + var flags = ref.flags; + if (flags & (SCOPE_CLASS_STATIC_BLOCK | SCOPE_CLASS_FIELD_INIT)) { return false } + if (flags & SCOPE_FUNCTION) { return (flags & SCOPE_ASYNC) > 0 } + } + return (this.inModule && this.options.ecmaVersion >= 13) || this.options.allowAwaitOutsideFunction + }; + + prototypeAccessors.allowSuper.get = function () { + var ref = this.currentThisScope(); + var flags = ref.flags; + return (flags & SCOPE_SUPER) > 0 || this.options.allowSuperOutsideMethod + }; + + prototypeAccessors.allowDirectSuper.get = function () { return (this.currentThisScope().flags & SCOPE_DIRECT_SUPER) > 0 }; + + prototypeAccessors.treatFunctionsAsVar.get = function () { return this.treatFunctionsAsVarInScope(this.currentScope()) }; + + prototypeAccessors.allowNewDotTarget.get = function () { + for (var i = this.scopeStack.length - 1; i >= 0; i--) { + var ref = this.scopeStack[i]; + var flags = ref.flags; + if (flags & (SCOPE_CLASS_STATIC_BLOCK | SCOPE_CLASS_FIELD_INIT) || + ((flags & SCOPE_FUNCTION) && !(flags & SCOPE_ARROW))) { return true } + } + return false + }; + + prototypeAccessors.inClassStaticBlock.get = function () { + return (this.currentVarScope().flags & SCOPE_CLASS_STATIC_BLOCK) > 0 + }; + + Parser.extend = function extend () { + var plugins = [], len = arguments.length; + while ( len-- ) plugins[ len ] = arguments[ len ]; + + var cls = this; + for (var i = 0; i < plugins.length; i++) { cls = plugins[i](cls); } + return cls + }; + + Parser.parse = function parse (input, options) { + return new this(options, input).parse() + }; + + Parser.parseExpressionAt = function parseExpressionAt (input, pos, options) { + var parser = new this(options, input, pos); + parser.nextToken(); + return parser.parseExpression() + }; + + Parser.tokenizer = function tokenizer (input, options) { + return new this(options, input) + }; + + Object.defineProperties( Parser.prototype, prototypeAccessors ); + + var pp$9 = Parser.prototype; + + // ## Parser utilities + + var literal = /^(?:'((?:\\[^]|[^'\\])*?)'|"((?:\\[^]|[^"\\])*?)")/; + pp$9.strictDirective = function(start) { + if (this.options.ecmaVersion < 5) { return false } + for (;;) { + // Try to find string literal. + skipWhiteSpace.lastIndex = start; + start += skipWhiteSpace.exec(this.input)[0].length; + var match = literal.exec(this.input.slice(start)); + if (!match) { return false } + if ((match[1] || match[2]) === "use strict") { + skipWhiteSpace.lastIndex = start + match[0].length; + var spaceAfter = skipWhiteSpace.exec(this.input), end = spaceAfter.index + spaceAfter[0].length; + var next = this.input.charAt(end); + return next === ";" || next === "}" || + (lineBreak.test(spaceAfter[0]) && + !(/[(`.[+\-/*%<>=,?^&]/.test(next) || next === "!" && this.input.charAt(end + 1) === "=")) + } + start += match[0].length; + + // Skip semicolon, if any. + skipWhiteSpace.lastIndex = start; + start += skipWhiteSpace.exec(this.input)[0].length; + if (this.input[start] === ";") + { start++; } + } + }; + + // Predicate that tests whether the next token is of the given + // type, and if yes, consumes it as a side effect. + + pp$9.eat = function(type) { + if (this.type === type) { + this.next(); + return true + } else { + return false + } + }; + + // Tests whether parsed token is a contextual keyword. + + pp$9.isContextual = function(name) { + return this.type === types$1.name && this.value === name && !this.containsEsc + }; + + // Consumes contextual keyword if possible. + + pp$9.eatContextual = function(name) { + if (!this.isContextual(name)) { return false } + this.next(); + return true + }; + + // Asserts that following token is given contextual keyword. + + pp$9.expectContextual = function(name) { + if (!this.eatContextual(name)) { this.unexpected(); } + }; + + // Test whether a semicolon can be inserted at the current position. + + pp$9.canInsertSemicolon = function() { + return this.type === types$1.eof || + this.type === types$1.braceR || + lineBreak.test(this.input.slice(this.lastTokEnd, this.start)) + }; + + pp$9.insertSemicolon = function() { + if (this.canInsertSemicolon()) { + if (this.options.onInsertedSemicolon) + { this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc); } + return true + } + }; + + // Consume a semicolon, or, failing that, see if we are allowed to + // pretend that there is a semicolon at this position. + + pp$9.semicolon = function() { + if (!this.eat(types$1.semi) && !this.insertSemicolon()) { this.unexpected(); } + }; + + pp$9.afterTrailingComma = function(tokType, notNext) { + if (this.type === tokType) { + if (this.options.onTrailingComma) + { this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc); } + if (!notNext) + { this.next(); } + return true + } + }; + + // Expect a token of a given type. If found, consume it, otherwise, + // raise an unexpected token error. + + pp$9.expect = function(type) { + this.eat(type) || this.unexpected(); + }; + + // Raise an unexpected token error. + + pp$9.unexpected = function(pos) { + this.raise(pos != null ? pos : this.start, "Unexpected token"); + }; + + var DestructuringErrors = function DestructuringErrors() { + this.shorthandAssign = + this.trailingComma = + this.parenthesizedAssign = + this.parenthesizedBind = + this.doubleProto = + -1; + }; + + pp$9.checkPatternErrors = function(refDestructuringErrors, isAssign) { + if (!refDestructuringErrors) { return } + if (refDestructuringErrors.trailingComma > -1) + { this.raiseRecoverable(refDestructuringErrors.trailingComma, "Comma is not permitted after the rest element"); } + var parens = isAssign ? refDestructuringErrors.parenthesizedAssign : refDestructuringErrors.parenthesizedBind; + if (parens > -1) { this.raiseRecoverable(parens, isAssign ? "Assigning to rvalue" : "Parenthesized pattern"); } + }; + + pp$9.checkExpressionErrors = function(refDestructuringErrors, andThrow) { + if (!refDestructuringErrors) { return false } + var shorthandAssign = refDestructuringErrors.shorthandAssign; + var doubleProto = refDestructuringErrors.doubleProto; + if (!andThrow) { return shorthandAssign >= 0 || doubleProto >= 0 } + if (shorthandAssign >= 0) + { this.raise(shorthandAssign, "Shorthand property assignments are valid only in destructuring patterns"); } + if (doubleProto >= 0) + { this.raiseRecoverable(doubleProto, "Redefinition of __proto__ property"); } + }; + + pp$9.checkYieldAwaitInDefaultParams = function() { + if (this.yieldPos && (!this.awaitPos || this.yieldPos < this.awaitPos)) + { this.raise(this.yieldPos, "Yield expression cannot be a default value"); } + if (this.awaitPos) + { this.raise(this.awaitPos, "Await expression cannot be a default value"); } + }; + + pp$9.isSimpleAssignTarget = function(expr) { + if (expr.type === "ParenthesizedExpression") + { return this.isSimpleAssignTarget(expr.expression) } + return expr.type === "Identifier" || expr.type === "MemberExpression" + }; + + var pp$8 = Parser.prototype; + + // ### Statement parsing + + // Parse a program. Initializes the parser, reads any number of + // statements, and wraps them in a Program node. Optionally takes a + // `program` argument. If present, the statements will be appended + // to its body instead of creating a new node. + + pp$8.parseTopLevel = function(node) { + var exports = Object.create(null); + if (!node.body) { node.body = []; } + while (this.type !== types$1.eof) { + var stmt = this.parseStatement(null, true, exports); + node.body.push(stmt); + } + if (this.inModule) + { for (var i = 0, list = Object.keys(this.undefinedExports); i < list.length; i += 1) + { + var name = list[i]; + + this.raiseRecoverable(this.undefinedExports[name].start, ("Export '" + name + "' is not defined")); + } } + this.adaptDirectivePrologue(node.body); + this.next(); + node.sourceType = this.options.sourceType; + return this.finishNode(node, "Program") + }; + + var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"}; + + pp$8.isLet = function(context) { + if (this.options.ecmaVersion < 6 || !this.isContextual("let")) { return false } + skipWhiteSpace.lastIndex = this.pos; + var skip = skipWhiteSpace.exec(this.input); + var next = this.pos + skip[0].length, nextCh = this.input.charCodeAt(next); + // For ambiguous cases, determine if a LexicalDeclaration (or only a + // Statement) is allowed here. If context is not empty then only a Statement + // is allowed. However, `let [` is an explicit negative lookahead for + // ExpressionStatement, so special-case it first. + if (nextCh === 91 || nextCh === 92) { return true } // '[', '\' + if (context) { return false } + + if (nextCh === 123 || nextCh > 0xd7ff && nextCh < 0xdc00) { return true } // '{', astral + if (isIdentifierStart(nextCh, true)) { + var pos = next + 1; + while (isIdentifierChar(nextCh = this.input.charCodeAt(pos), true)) { ++pos; } + if (nextCh === 92 || nextCh > 0xd7ff && nextCh < 0xdc00) { return true } + var ident = this.input.slice(next, pos); + if (!keywordRelationalOperator.test(ident)) { return true } + } + return false + }; + + // check 'async [no LineTerminator here] function' + // - 'async /*foo*/ function' is OK. + // - 'async /*\n*/ function' is invalid. + pp$8.isAsyncFunction = function() { + if (this.options.ecmaVersion < 8 || !this.isContextual("async")) + { return false } + + skipWhiteSpace.lastIndex = this.pos; + var skip = skipWhiteSpace.exec(this.input); + var next = this.pos + skip[0].length, after; + return !lineBreak.test(this.input.slice(this.pos, next)) && + this.input.slice(next, next + 8) === "function" && + (next + 8 === this.input.length || + !(isIdentifierChar(after = this.input.charCodeAt(next + 8)) || after > 0xd7ff && after < 0xdc00)) + }; + + pp$8.isUsingKeyword = function(isAwaitUsing, isFor) { + if (this.options.ecmaVersion < 17 || !this.isContextual(isAwaitUsing ? "await" : "using")) + { return false } + + skipWhiteSpace.lastIndex = this.pos; + var skip = skipWhiteSpace.exec(this.input); + var next = this.pos + skip[0].length; + + if (lineBreak.test(this.input.slice(this.pos, next))) { return false } + + if (isAwaitUsing) { + var awaitEndPos = next + 5 /* await */, after; + if (this.input.slice(next, awaitEndPos) !== "using" || + awaitEndPos === this.input.length || + isIdentifierChar(after = this.input.charCodeAt(awaitEndPos)) || + (after > 0xd7ff && after < 0xdc00) + ) { return false } + + skipWhiteSpace.lastIndex = awaitEndPos; + var skipAfterUsing = skipWhiteSpace.exec(this.input); + if (skipAfterUsing && lineBreak.test(this.input.slice(awaitEndPos, awaitEndPos + skipAfterUsing[0].length))) { return false } + } + + if (isFor) { + var ofEndPos = next + 2 /* of */, after$1; + if (this.input.slice(next, ofEndPos) === "of") { + if (ofEndPos === this.input.length || + (!isIdentifierChar(after$1 = this.input.charCodeAt(ofEndPos)) && !(after$1 > 0xd7ff && after$1 < 0xdc00))) { return false } + } + } + + var ch = this.input.charCodeAt(next); + return isIdentifierStart(ch, true) || ch === 92 // '\' + }; + + pp$8.isAwaitUsing = function(isFor) { + return this.isUsingKeyword(true, isFor) + }; + + pp$8.isUsing = function(isFor) { + return this.isUsingKeyword(false, isFor) + }; + + // Parse a single statement. + // + // If expecting a statement and finding a slash operator, parse a + // regular expression literal. This is to handle cases like + // `if (foo) /blah/.exec(foo)`, where looking at the previous token + // does not help. + + pp$8.parseStatement = function(context, topLevel, exports) { + var starttype = this.type, node = this.startNode(), kind; + + if (this.isLet(context)) { + starttype = types$1._var; + kind = "let"; + } + + // Most types of statements are recognized by the keyword they + // start with. Many are trivial to parse, some require a bit of + // complexity. + + switch (starttype) { + case types$1._break: case types$1._continue: return this.parseBreakContinueStatement(node, starttype.keyword) + case types$1._debugger: return this.parseDebuggerStatement(node) + case types$1._do: return this.parseDoStatement(node) + case types$1._for: return this.parseForStatement(node) + case types$1._function: + // Function as sole body of either an if statement or a labeled statement + // works, but not when it is part of a labeled statement that is the sole + // body of an if statement. + if ((context && (this.strict || context !== "if" && context !== "label")) && this.options.ecmaVersion >= 6) { this.unexpected(); } + return this.parseFunctionStatement(node, false, !context) + case types$1._class: + if (context) { this.unexpected(); } + return this.parseClass(node, true) + case types$1._if: return this.parseIfStatement(node) + case types$1._return: return this.parseReturnStatement(node) + case types$1._switch: return this.parseSwitchStatement(node) + case types$1._throw: return this.parseThrowStatement(node) + case types$1._try: return this.parseTryStatement(node) + case types$1._const: case types$1._var: + kind = kind || this.value; + if (context && kind !== "var") { this.unexpected(); } + return this.parseVarStatement(node, kind) + case types$1._while: return this.parseWhileStatement(node) + case types$1._with: return this.parseWithStatement(node) + case types$1.braceL: return this.parseBlock(true, node) + case types$1.semi: return this.parseEmptyStatement(node) + case types$1._export: + case types$1._import: + if (this.options.ecmaVersion > 10 && starttype === types$1._import) { + skipWhiteSpace.lastIndex = this.pos; + var skip = skipWhiteSpace.exec(this.input); + var next = this.pos + skip[0].length, nextCh = this.input.charCodeAt(next); + if (nextCh === 40 || nextCh === 46) // '(' or '.' + { return this.parseExpressionStatement(node, this.parseExpression()) } + } + + if (!this.options.allowImportExportEverywhere) { + if (!topLevel) + { this.raise(this.start, "'import' and 'export' may only appear at the top level"); } + if (!this.inModule) + { this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'"); } + } + return starttype === types$1._import ? this.parseImport(node) : this.parseExport(node, exports) + + // If the statement does not start with a statement keyword or a + // brace, it's an ExpressionStatement or LabeledStatement. We + // simply start parsing an expression, and afterwards, if the + // next token is a colon and the expression was a simple + // Identifier node, we switch to interpreting it as a label. + default: + if (this.isAsyncFunction()) { + if (context) { this.unexpected(); } + this.next(); + return this.parseFunctionStatement(node, true, !context) + } + + var usingKind = this.isAwaitUsing(false) ? "await using" : this.isUsing(false) ? "using" : null; + if (usingKind) { + if (topLevel && this.options.sourceType === "script") { + this.raise(this.start, "Using declaration cannot appear in the top level when source type is `script`"); + } + if (usingKind === "await using") { + if (!this.canAwait) { + this.raise(this.start, "Await using cannot appear outside of async function"); + } + this.next(); + } + this.next(); + this.parseVar(node, false, usingKind); + this.semicolon(); + return this.finishNode(node, "VariableDeclaration") + } + + var maybeName = this.value, expr = this.parseExpression(); + if (starttype === types$1.name && expr.type === "Identifier" && this.eat(types$1.colon)) + { return this.parseLabeledStatement(node, maybeName, expr, context) } + else { return this.parseExpressionStatement(node, expr) } + } + }; + + pp$8.parseBreakContinueStatement = function(node, keyword) { + var isBreak = keyword === "break"; + this.next(); + if (this.eat(types$1.semi) || this.insertSemicolon()) { node.label = null; } + else if (this.type !== types$1.name) { this.unexpected(); } + else { + node.label = this.parseIdent(); + this.semicolon(); + } + + // Verify that there is an actual destination to break or + // continue to. + var i = 0; + for (; i < this.labels.length; ++i) { + var lab = this.labels[i]; + if (node.label == null || lab.name === node.label.name) { + if (lab.kind != null && (isBreak || lab.kind === "loop")) { break } + if (node.label && isBreak) { break } + } + } + if (i === this.labels.length) { this.raise(node.start, "Unsyntactic " + keyword); } + return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement") + }; + + pp$8.parseDebuggerStatement = function(node) { + this.next(); + this.semicolon(); + return this.finishNode(node, "DebuggerStatement") + }; + + pp$8.parseDoStatement = function(node) { + this.next(); + this.labels.push(loopLabel); + node.body = this.parseStatement("do"); + this.labels.pop(); + this.expect(types$1._while); + node.test = this.parseParenExpression(); + if (this.options.ecmaVersion >= 6) + { this.eat(types$1.semi); } + else + { this.semicolon(); } + return this.finishNode(node, "DoWhileStatement") + }; + + // Disambiguating between a `for` and a `for`/`in` or `for`/`of` + // loop is non-trivial. Basically, we have to parse the init `var` + // statement or expression, disallowing the `in` operator (see + // the second parameter to `parseExpression`), and then check + // whether the next token is `in` or `of`. When there is no init + // part (semicolon immediately after the opening parenthesis), it + // is a regular `for` loop. + + pp$8.parseForStatement = function(node) { + this.next(); + var awaitAt = (this.options.ecmaVersion >= 9 && this.canAwait && this.eatContextual("await")) ? this.lastTokStart : -1; + this.labels.push(loopLabel); + this.enterScope(0); + this.expect(types$1.parenL); + if (this.type === types$1.semi) { + if (awaitAt > -1) { this.unexpected(awaitAt); } + return this.parseFor(node, null) + } + var isLet = this.isLet(); + if (this.type === types$1._var || this.type === types$1._const || isLet) { + var init$1 = this.startNode(), kind = isLet ? "let" : this.value; + this.next(); + this.parseVar(init$1, true, kind); + this.finishNode(init$1, "VariableDeclaration"); + return this.parseForAfterInit(node, init$1, awaitAt) + } + var startsWithLet = this.isContextual("let"), isForOf = false; + + var usingKind = this.isUsing(true) ? "using" : this.isAwaitUsing(true) ? "await using" : null; + if (usingKind) { + var init$2 = this.startNode(); + this.next(); + if (usingKind === "await using") { this.next(); } + this.parseVar(init$2, true, usingKind); + this.finishNode(init$2, "VariableDeclaration"); + return this.parseForAfterInit(node, init$2, awaitAt) + } + var containsEsc = this.containsEsc; + var refDestructuringErrors = new DestructuringErrors; + var initPos = this.start; + var init = awaitAt > -1 + ? this.parseExprSubscripts(refDestructuringErrors, "await") + : this.parseExpression(true, refDestructuringErrors); + if (this.type === types$1._in || (isForOf = this.options.ecmaVersion >= 6 && this.isContextual("of"))) { + if (awaitAt > -1) { // implies `ecmaVersion >= 9` (see declaration of awaitAt) + if (this.type === types$1._in) { this.unexpected(awaitAt); } + node.await = true; + } else if (isForOf && this.options.ecmaVersion >= 8) { + if (init.start === initPos && !containsEsc && init.type === "Identifier" && init.name === "async") { this.unexpected(); } + else if (this.options.ecmaVersion >= 9) { node.await = false; } + } + if (startsWithLet && isForOf) { this.raise(init.start, "The left-hand side of a for-of loop may not start with 'let'."); } + this.toAssignable(init, false, refDestructuringErrors); + this.checkLValPattern(init); + return this.parseForIn(node, init) + } else { + this.checkExpressionErrors(refDestructuringErrors, true); + } + if (awaitAt > -1) { this.unexpected(awaitAt); } + return this.parseFor(node, init) + }; + + // Helper method to parse for loop after variable initialization + pp$8.parseForAfterInit = function(node, init, awaitAt) { + if ((this.type === types$1._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) && init.declarations.length === 1) { + if (this.options.ecmaVersion >= 9) { + if (this.type === types$1._in) { + if (awaitAt > -1) { this.unexpected(awaitAt); } + } else { node.await = awaitAt > -1; } + } + return this.parseForIn(node, init) + } + if (awaitAt > -1) { this.unexpected(awaitAt); } + return this.parseFor(node, init) + }; + + pp$8.parseFunctionStatement = function(node, isAsync, declarationPosition) { + this.next(); + return this.parseFunction(node, FUNC_STATEMENT | (declarationPosition ? 0 : FUNC_HANGING_STATEMENT), false, isAsync) + }; + + pp$8.parseIfStatement = function(node) { + this.next(); + node.test = this.parseParenExpression(); + // allow function declarations in branches, but only in non-strict mode + node.consequent = this.parseStatement("if"); + node.alternate = this.eat(types$1._else) ? this.parseStatement("if") : null; + return this.finishNode(node, "IfStatement") + }; + + pp$8.parseReturnStatement = function(node) { + if (!this.inFunction && !this.options.allowReturnOutsideFunction) + { this.raise(this.start, "'return' outside of function"); } + this.next(); + + // In `return` (and `break`/`continue`), the keywords with + // optional arguments, we eagerly look for a semicolon or the + // possibility to insert one. + + if (this.eat(types$1.semi) || this.insertSemicolon()) { node.argument = null; } + else { node.argument = this.parseExpression(); this.semicolon(); } + return this.finishNode(node, "ReturnStatement") + }; + + pp$8.parseSwitchStatement = function(node) { + this.next(); + node.discriminant = this.parseParenExpression(); + node.cases = []; + this.expect(types$1.braceL); + this.labels.push(switchLabel); + this.enterScope(0); + + // Statements under must be grouped (by label) in SwitchCase + // nodes. `cur` is used to keep the node that we are currently + // adding statements to. + + var cur; + for (var sawDefault = false; this.type !== types$1.braceR;) { + if (this.type === types$1._case || this.type === types$1._default) { + var isCase = this.type === types$1._case; + if (cur) { this.finishNode(cur, "SwitchCase"); } + node.cases.push(cur = this.startNode()); + cur.consequent = []; + this.next(); + if (isCase) { + cur.test = this.parseExpression(); + } else { + if (sawDefault) { this.raiseRecoverable(this.lastTokStart, "Multiple default clauses"); } + sawDefault = true; + cur.test = null; + } + this.expect(types$1.colon); + } else { + if (!cur) { this.unexpected(); } + cur.consequent.push(this.parseStatement(null)); + } + } + this.exitScope(); + if (cur) { this.finishNode(cur, "SwitchCase"); } + this.next(); // Closing brace + this.labels.pop(); + return this.finishNode(node, "SwitchStatement") + }; + + pp$8.parseThrowStatement = function(node) { + this.next(); + if (lineBreak.test(this.input.slice(this.lastTokEnd, this.start))) + { this.raise(this.lastTokEnd, "Illegal newline after throw"); } + node.argument = this.parseExpression(); + this.semicolon(); + return this.finishNode(node, "ThrowStatement") + }; + + // Reused empty array added for node fields that are always empty. + + var empty$1 = []; + + pp$8.parseCatchClauseParam = function() { + var param = this.parseBindingAtom(); + var simple = param.type === "Identifier"; + this.enterScope(simple ? SCOPE_SIMPLE_CATCH : 0); + this.checkLValPattern(param, simple ? BIND_SIMPLE_CATCH : BIND_LEXICAL); + this.expect(types$1.parenR); + + return param + }; + + pp$8.parseTryStatement = function(node) { + this.next(); + node.block = this.parseBlock(); + node.handler = null; + if (this.type === types$1._catch) { + var clause = this.startNode(); + this.next(); + if (this.eat(types$1.parenL)) { + clause.param = this.parseCatchClauseParam(); + } else { + if (this.options.ecmaVersion < 10) { this.unexpected(); } + clause.param = null; + this.enterScope(0); + } + clause.body = this.parseBlock(false); + this.exitScope(); + node.handler = this.finishNode(clause, "CatchClause"); + } + node.finalizer = this.eat(types$1._finally) ? this.parseBlock() : null; + if (!node.handler && !node.finalizer) + { this.raise(node.start, "Missing catch or finally clause"); } + return this.finishNode(node, "TryStatement") + }; + + pp$8.parseVarStatement = function(node, kind, allowMissingInitializer) { + this.next(); + this.parseVar(node, false, kind, allowMissingInitializer); + this.semicolon(); + return this.finishNode(node, "VariableDeclaration") + }; + + pp$8.parseWhileStatement = function(node) { + this.next(); + node.test = this.parseParenExpression(); + this.labels.push(loopLabel); + node.body = this.parseStatement("while"); + this.labels.pop(); + return this.finishNode(node, "WhileStatement") + }; + + pp$8.parseWithStatement = function(node) { + if (this.strict) { this.raise(this.start, "'with' in strict mode"); } + this.next(); + node.object = this.parseParenExpression(); + node.body = this.parseStatement("with"); + return this.finishNode(node, "WithStatement") + }; + + pp$8.parseEmptyStatement = function(node) { + this.next(); + return this.finishNode(node, "EmptyStatement") + }; + + pp$8.parseLabeledStatement = function(node, maybeName, expr, context) { + for (var i$1 = 0, list = this.labels; i$1 < list.length; i$1 += 1) + { + var label = list[i$1]; + + if (label.name === maybeName) + { this.raise(expr.start, "Label '" + maybeName + "' is already declared"); + } } + var kind = this.type.isLoop ? "loop" : this.type === types$1._switch ? "switch" : null; + for (var i = this.labels.length - 1; i >= 0; i--) { + var label$1 = this.labels[i]; + if (label$1.statementStart === node.start) { + // Update information about previous labels on this node + label$1.statementStart = this.start; + label$1.kind = kind; + } else { break } + } + this.labels.push({name: maybeName, kind: kind, statementStart: this.start}); + node.body = this.parseStatement(context ? context.indexOf("label") === -1 ? context + "label" : context : "label"); + this.labels.pop(); + node.label = expr; + return this.finishNode(node, "LabeledStatement") + }; + + pp$8.parseExpressionStatement = function(node, expr) { + node.expression = expr; + this.semicolon(); + return this.finishNode(node, "ExpressionStatement") + }; + + // Parse a semicolon-enclosed block of statements, handling `"use + // strict"` declarations when `allowStrict` is true (used for + // function bodies). + + pp$8.parseBlock = function(createNewLexicalScope, node, exitStrict) { + if ( createNewLexicalScope === void 0 ) createNewLexicalScope = true; + if ( node === void 0 ) node = this.startNode(); + + node.body = []; + this.expect(types$1.braceL); + if (createNewLexicalScope) { this.enterScope(0); } + while (this.type !== types$1.braceR) { + var stmt = this.parseStatement(null); + node.body.push(stmt); + } + if (exitStrict) { this.strict = false; } + this.next(); + if (createNewLexicalScope) { this.exitScope(); } + return this.finishNode(node, "BlockStatement") + }; + + // Parse a regular `for` loop. The disambiguation code in + // `parseStatement` will already have parsed the init statement or + // expression. + + pp$8.parseFor = function(node, init) { + node.init = init; + this.expect(types$1.semi); + node.test = this.type === types$1.semi ? null : this.parseExpression(); + this.expect(types$1.semi); + node.update = this.type === types$1.parenR ? null : this.parseExpression(); + this.expect(types$1.parenR); + node.body = this.parseStatement("for"); + this.exitScope(); + this.labels.pop(); + return this.finishNode(node, "ForStatement") + }; + + // Parse a `for`/`in` and `for`/`of` loop, which are almost + // same from parser's perspective. + + pp$8.parseForIn = function(node, init) { + var isForIn = this.type === types$1._in; + this.next(); + + if ( + init.type === "VariableDeclaration" && + init.declarations[0].init != null && + ( + !isForIn || + this.options.ecmaVersion < 8 || + this.strict || + init.kind !== "var" || + init.declarations[0].id.type !== "Identifier" + ) + ) { + this.raise( + init.start, + ((isForIn ? "for-in" : "for-of") + " loop variable declaration may not have an initializer") + ); + } + node.left = init; + node.right = isForIn ? this.parseExpression() : this.parseMaybeAssign(); + this.expect(types$1.parenR); + node.body = this.parseStatement("for"); + this.exitScope(); + this.labels.pop(); + return this.finishNode(node, isForIn ? "ForInStatement" : "ForOfStatement") + }; + + // Parse a list of variable declarations. + + pp$8.parseVar = function(node, isFor, kind, allowMissingInitializer) { + node.declarations = []; + node.kind = kind; + for (;;) { + var decl = this.startNode(); + this.parseVarId(decl, kind); + if (this.eat(types$1.eq)) { + decl.init = this.parseMaybeAssign(isFor); + } else if (!allowMissingInitializer && kind === "const" && !(this.type === types$1._in || (this.options.ecmaVersion >= 6 && this.isContextual("of")))) { + this.unexpected(); + } else if (!allowMissingInitializer && (kind === "using" || kind === "await using") && this.options.ecmaVersion >= 17 && this.type !== types$1._in && !this.isContextual("of")) { + this.raise(this.lastTokEnd, ("Missing initializer in " + kind + " declaration")); + } else if (!allowMissingInitializer && decl.id.type !== "Identifier" && !(isFor && (this.type === types$1._in || this.isContextual("of")))) { + this.raise(this.lastTokEnd, "Complex binding patterns require an initialization value"); + } else { + decl.init = null; + } + node.declarations.push(this.finishNode(decl, "VariableDeclarator")); + if (!this.eat(types$1.comma)) { break } + } + return node + }; + + pp$8.parseVarId = function(decl, kind) { + decl.id = kind === "using" || kind === "await using" + ? this.parseIdent() + : this.parseBindingAtom(); + + this.checkLValPattern(decl.id, kind === "var" ? BIND_VAR : BIND_LEXICAL, false); + }; + + var FUNC_STATEMENT = 1, FUNC_HANGING_STATEMENT = 2, FUNC_NULLABLE_ID = 4; + + // Parse a function declaration or literal (depending on the + // `statement & FUNC_STATEMENT`). + + // Remove `allowExpressionBody` for 7.0.0, as it is only called with false + pp$8.parseFunction = function(node, statement, allowExpressionBody, isAsync, forInit) { + this.initFunction(node); + if (this.options.ecmaVersion >= 9 || this.options.ecmaVersion >= 6 && !isAsync) { + if (this.type === types$1.star && (statement & FUNC_HANGING_STATEMENT)) + { this.unexpected(); } + node.generator = this.eat(types$1.star); + } + if (this.options.ecmaVersion >= 8) + { node.async = !!isAsync; } + + if (statement & FUNC_STATEMENT) { + node.id = (statement & FUNC_NULLABLE_ID) && this.type !== types$1.name ? null : this.parseIdent(); + if (node.id && !(statement & FUNC_HANGING_STATEMENT)) + // If it is a regular function declaration in sloppy mode, then it is + // subject to Annex B semantics (BIND_FUNCTION). Otherwise, the binding + // mode depends on properties of the current scope (see + // treatFunctionsAsVar). + { this.checkLValSimple(node.id, (this.strict || node.generator || node.async) ? this.treatFunctionsAsVar ? BIND_VAR : BIND_LEXICAL : BIND_FUNCTION); } + } + + var oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos; + this.yieldPos = 0; + this.awaitPos = 0; + this.awaitIdentPos = 0; + this.enterScope(functionFlags(node.async, node.generator)); + + if (!(statement & FUNC_STATEMENT)) + { node.id = this.type === types$1.name ? this.parseIdent() : null; } + + this.parseFunctionParams(node); + this.parseFunctionBody(node, allowExpressionBody, false, forInit); + + this.yieldPos = oldYieldPos; + this.awaitPos = oldAwaitPos; + this.awaitIdentPos = oldAwaitIdentPos; + return this.finishNode(node, (statement & FUNC_STATEMENT) ? "FunctionDeclaration" : "FunctionExpression") + }; + + pp$8.parseFunctionParams = function(node) { + this.expect(types$1.parenL); + node.params = this.parseBindingList(types$1.parenR, false, this.options.ecmaVersion >= 8); + this.checkYieldAwaitInDefaultParams(); + }; + + // Parse a class declaration or literal (depending on the + // `isStatement` parameter). + + pp$8.parseClass = function(node, isStatement) { + this.next(); + + // ecma-262 14.6 Class Definitions + // A class definition is always strict mode code. + var oldStrict = this.strict; + this.strict = true; + + this.parseClassId(node, isStatement); + this.parseClassSuper(node); + var privateNameMap = this.enterClassBody(); + var classBody = this.startNode(); + var hadConstructor = false; + classBody.body = []; + this.expect(types$1.braceL); + while (this.type !== types$1.braceR) { + var element = this.parseClassElement(node.superClass !== null); + if (element) { + classBody.body.push(element); + if (element.type === "MethodDefinition" && element.kind === "constructor") { + if (hadConstructor) { this.raiseRecoverable(element.start, "Duplicate constructor in the same class"); } + hadConstructor = true; + } else if (element.key && element.key.type === "PrivateIdentifier" && isPrivateNameConflicted(privateNameMap, element)) { + this.raiseRecoverable(element.key.start, ("Identifier '#" + (element.key.name) + "' has already been declared")); + } + } + } + this.strict = oldStrict; + this.next(); + node.body = this.finishNode(classBody, "ClassBody"); + this.exitClassBody(); + return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression") + }; + + pp$8.parseClassElement = function(constructorAllowsSuper) { + if (this.eat(types$1.semi)) { return null } + + var ecmaVersion = this.options.ecmaVersion; + var node = this.startNode(); + var keyName = ""; + var isGenerator = false; + var isAsync = false; + var kind = "method"; + var isStatic = false; + + if (this.eatContextual("static")) { + // Parse static init block + if (ecmaVersion >= 13 && this.eat(types$1.braceL)) { + this.parseClassStaticBlock(node); + return node + } + if (this.isClassElementNameStart() || this.type === types$1.star) { + isStatic = true; + } else { + keyName = "static"; + } + } + node.static = isStatic; + if (!keyName && ecmaVersion >= 8 && this.eatContextual("async")) { + if ((this.isClassElementNameStart() || this.type === types$1.star) && !this.canInsertSemicolon()) { + isAsync = true; + } else { + keyName = "async"; + } + } + if (!keyName && (ecmaVersion >= 9 || !isAsync) && this.eat(types$1.star)) { + isGenerator = true; + } + if (!keyName && !isAsync && !isGenerator) { + var lastValue = this.value; + if (this.eatContextual("get") || this.eatContextual("set")) { + if (this.isClassElementNameStart()) { + kind = lastValue; + } else { + keyName = lastValue; + } + } + } + + // Parse element name + if (keyName) { + // 'async', 'get', 'set', or 'static' were not a keyword contextually. + // The last token is any of those. Make it the element name. + node.computed = false; + node.key = this.startNodeAt(this.lastTokStart, this.lastTokStartLoc); + node.key.name = keyName; + this.finishNode(node.key, "Identifier"); + } else { + this.parseClassElementName(node); + } + + // Parse element value + if (ecmaVersion < 13 || this.type === types$1.parenL || kind !== "method" || isGenerator || isAsync) { + var isConstructor = !node.static && checkKeyName(node, "constructor"); + var allowsDirectSuper = isConstructor && constructorAllowsSuper; + // Couldn't move this check into the 'parseClassMethod' method for backward compatibility. + if (isConstructor && kind !== "method") { this.raise(node.key.start, "Constructor can't have get/set modifier"); } + node.kind = isConstructor ? "constructor" : kind; + this.parseClassMethod(node, isGenerator, isAsync, allowsDirectSuper); + } else { + this.parseClassField(node); + } + + return node + }; + + pp$8.isClassElementNameStart = function() { + return ( + this.type === types$1.name || + this.type === types$1.privateId || + this.type === types$1.num || + this.type === types$1.string || + this.type === types$1.bracketL || + this.type.keyword + ) + }; + + pp$8.parseClassElementName = function(element) { + if (this.type === types$1.privateId) { + if (this.value === "constructor") { + this.raise(this.start, "Classes can't have an element named '#constructor'"); + } + element.computed = false; + element.key = this.parsePrivateIdent(); + } else { + this.parsePropertyName(element); + } + }; + + pp$8.parseClassMethod = function(method, isGenerator, isAsync, allowsDirectSuper) { + // Check key and flags + var key = method.key; + if (method.kind === "constructor") { + if (isGenerator) { this.raise(key.start, "Constructor can't be a generator"); } + if (isAsync) { this.raise(key.start, "Constructor can't be an async method"); } + } else if (method.static && checkKeyName(method, "prototype")) { + this.raise(key.start, "Classes may not have a static property named prototype"); + } + + // Parse value + var value = method.value = this.parseMethod(isGenerator, isAsync, allowsDirectSuper); + + // Check value + if (method.kind === "get" && value.params.length !== 0) + { this.raiseRecoverable(value.start, "getter should have no params"); } + if (method.kind === "set" && value.params.length !== 1) + { this.raiseRecoverable(value.start, "setter should have exactly one param"); } + if (method.kind === "set" && value.params[0].type === "RestElement") + { this.raiseRecoverable(value.params[0].start, "Setter cannot use rest params"); } + + return this.finishNode(method, "MethodDefinition") + }; + + pp$8.parseClassField = function(field) { + if (checkKeyName(field, "constructor")) { + this.raise(field.key.start, "Classes can't have a field named 'constructor'"); + } else if (field.static && checkKeyName(field, "prototype")) { + this.raise(field.key.start, "Classes can't have a static field named 'prototype'"); + } + + if (this.eat(types$1.eq)) { + // To raise SyntaxError if 'arguments' exists in the initializer. + this.enterScope(SCOPE_CLASS_FIELD_INIT | SCOPE_SUPER); + field.value = this.parseMaybeAssign(); + this.exitScope(); + } else { + field.value = null; + } + this.semicolon(); + + return this.finishNode(field, "PropertyDefinition") + }; + + pp$8.parseClassStaticBlock = function(node) { + node.body = []; + + var oldLabels = this.labels; + this.labels = []; + this.enterScope(SCOPE_CLASS_STATIC_BLOCK | SCOPE_SUPER); + while (this.type !== types$1.braceR) { + var stmt = this.parseStatement(null); + node.body.push(stmt); + } + this.next(); + this.exitScope(); + this.labels = oldLabels; + + return this.finishNode(node, "StaticBlock") + }; + + pp$8.parseClassId = function(node, isStatement) { + if (this.type === types$1.name) { + node.id = this.parseIdent(); + if (isStatement) + { this.checkLValSimple(node.id, BIND_LEXICAL, false); } + } else { + if (isStatement === true) + { this.unexpected(); } + node.id = null; + } + }; + + pp$8.parseClassSuper = function(node) { + node.superClass = this.eat(types$1._extends) ? this.parseExprSubscripts(null, false) : null; + }; + + pp$8.enterClassBody = function() { + var element = {declared: Object.create(null), used: []}; + this.privateNameStack.push(element); + return element.declared + }; + + pp$8.exitClassBody = function() { + var ref = this.privateNameStack.pop(); + var declared = ref.declared; + var used = ref.used; + if (!this.options.checkPrivateFields) { return } + var len = this.privateNameStack.length; + var parent = len === 0 ? null : this.privateNameStack[len - 1]; + for (var i = 0; i < used.length; ++i) { + var id = used[i]; + if (!hasOwn(declared, id.name)) { + if (parent) { + parent.used.push(id); + } else { + this.raiseRecoverable(id.start, ("Private field '#" + (id.name) + "' must be declared in an enclosing class")); + } + } + } + }; + + function isPrivateNameConflicted(privateNameMap, element) { + var name = element.key.name; + var curr = privateNameMap[name]; + + var next = "true"; + if (element.type === "MethodDefinition" && (element.kind === "get" || element.kind === "set")) { + next = (element.static ? "s" : "i") + element.kind; + } + + // `class { get #a(){}; static set #a(_){} }` is also conflict. + if ( + curr === "iget" && next === "iset" || + curr === "iset" && next === "iget" || + curr === "sget" && next === "sset" || + curr === "sset" && next === "sget" + ) { + privateNameMap[name] = "true"; + return false + } else if (!curr) { + privateNameMap[name] = next; + return false + } else { + return true + } + } + + function checkKeyName(node, name) { + var computed = node.computed; + var key = node.key; + return !computed && ( + key.type === "Identifier" && key.name === name || + key.type === "Literal" && key.value === name + ) + } + + // Parses module export declaration. + + pp$8.parseExportAllDeclaration = function(node, exports) { + if (this.options.ecmaVersion >= 11) { + if (this.eatContextual("as")) { + node.exported = this.parseModuleExportName(); + this.checkExport(exports, node.exported, this.lastTokStart); + } else { + node.exported = null; + } + } + this.expectContextual("from"); + if (this.type !== types$1.string) { this.unexpected(); } + node.source = this.parseExprAtom(); + if (this.options.ecmaVersion >= 16) + { node.attributes = this.parseWithClause(); } + this.semicolon(); + return this.finishNode(node, "ExportAllDeclaration") + }; + + pp$8.parseExport = function(node, exports) { + this.next(); + // export * from '...' + if (this.eat(types$1.star)) { + return this.parseExportAllDeclaration(node, exports) + } + if (this.eat(types$1._default)) { // export default ... + this.checkExport(exports, "default", this.lastTokStart); + node.declaration = this.parseExportDefaultDeclaration(); + return this.finishNode(node, "ExportDefaultDeclaration") + } + // export var|const|let|function|class ... + if (this.shouldParseExportStatement()) { + node.declaration = this.parseExportDeclaration(node); + if (node.declaration.type === "VariableDeclaration") + { this.checkVariableExport(exports, node.declaration.declarations); } + else + { this.checkExport(exports, node.declaration.id, node.declaration.id.start); } + node.specifiers = []; + node.source = null; + if (this.options.ecmaVersion >= 16) + { node.attributes = []; } + } else { // export { x, y as z } [from '...'] + node.declaration = null; + node.specifiers = this.parseExportSpecifiers(exports); + if (this.eatContextual("from")) { + if (this.type !== types$1.string) { this.unexpected(); } + node.source = this.parseExprAtom(); + if (this.options.ecmaVersion >= 16) + { node.attributes = this.parseWithClause(); } + } else { + for (var i = 0, list = node.specifiers; i < list.length; i += 1) { + // check for keywords used as local names + var spec = list[i]; + + this.checkUnreserved(spec.local); + // check if export is defined + this.checkLocalExport(spec.local); + + if (spec.local.type === "Literal") { + this.raise(spec.local.start, "A string literal cannot be used as an exported binding without `from`."); + } + } + + node.source = null; + if (this.options.ecmaVersion >= 16) + { node.attributes = []; } + } + this.semicolon(); + } + return this.finishNode(node, "ExportNamedDeclaration") + }; + + pp$8.parseExportDeclaration = function(node) { + return this.parseStatement(null) + }; + + pp$8.parseExportDefaultDeclaration = function() { + var isAsync; + if (this.type === types$1._function || (isAsync = this.isAsyncFunction())) { + var fNode = this.startNode(); + this.next(); + if (isAsync) { this.next(); } + return this.parseFunction(fNode, FUNC_STATEMENT | FUNC_NULLABLE_ID, false, isAsync) + } else if (this.type === types$1._class) { + var cNode = this.startNode(); + return this.parseClass(cNode, "nullableID") + } else { + var declaration = this.parseMaybeAssign(); + this.semicolon(); + return declaration + } + }; + + pp$8.checkExport = function(exports, name, pos) { + if (!exports) { return } + if (typeof name !== "string") + { name = name.type === "Identifier" ? name.name : name.value; } + if (hasOwn(exports, name)) + { this.raiseRecoverable(pos, "Duplicate export '" + name + "'"); } + exports[name] = true; + }; + + pp$8.checkPatternExport = function(exports, pat) { + var type = pat.type; + if (type === "Identifier") + { this.checkExport(exports, pat, pat.start); } + else if (type === "ObjectPattern") + { for (var i = 0, list = pat.properties; i < list.length; i += 1) + { + var prop = list[i]; + + this.checkPatternExport(exports, prop); + } } + else if (type === "ArrayPattern") + { for (var i$1 = 0, list$1 = pat.elements; i$1 < list$1.length; i$1 += 1) { + var elt = list$1[i$1]; + + if (elt) { this.checkPatternExport(exports, elt); } + } } + else if (type === "Property") + { this.checkPatternExport(exports, pat.value); } + else if (type === "AssignmentPattern") + { this.checkPatternExport(exports, pat.left); } + else if (type === "RestElement") + { this.checkPatternExport(exports, pat.argument); } + }; + + pp$8.checkVariableExport = function(exports, decls) { + if (!exports) { return } + for (var i = 0, list = decls; i < list.length; i += 1) + { + var decl = list[i]; + + this.checkPatternExport(exports, decl.id); + } + }; + + pp$8.shouldParseExportStatement = function() { + return this.type.keyword === "var" || + this.type.keyword === "const" || + this.type.keyword === "class" || + this.type.keyword === "function" || + this.isLet() || + this.isAsyncFunction() + }; + + // Parses a comma-separated list of module exports. + + pp$8.parseExportSpecifier = function(exports) { + var node = this.startNode(); + node.local = this.parseModuleExportName(); + + node.exported = this.eatContextual("as") ? this.parseModuleExportName() : node.local; + this.checkExport( + exports, + node.exported, + node.exported.start + ); + + return this.finishNode(node, "ExportSpecifier") + }; + + pp$8.parseExportSpecifiers = function(exports) { + var nodes = [], first = true; + // export { x, y as z } [from '...'] + this.expect(types$1.braceL); + while (!this.eat(types$1.braceR)) { + if (!first) { + this.expect(types$1.comma); + if (this.afterTrailingComma(types$1.braceR)) { break } + } else { first = false; } + + nodes.push(this.parseExportSpecifier(exports)); + } + return nodes + }; + + // Parses import declaration. + + pp$8.parseImport = function(node) { + this.next(); + + // import '...' + if (this.type === types$1.string) { + node.specifiers = empty$1; + node.source = this.parseExprAtom(); + } else { + node.specifiers = this.parseImportSpecifiers(); + this.expectContextual("from"); + node.source = this.type === types$1.string ? this.parseExprAtom() : this.unexpected(); + } + if (this.options.ecmaVersion >= 16) + { node.attributes = this.parseWithClause(); } + this.semicolon(); + return this.finishNode(node, "ImportDeclaration") + }; + + // Parses a comma-separated list of module imports. + + pp$8.parseImportSpecifier = function() { + var node = this.startNode(); + node.imported = this.parseModuleExportName(); + + if (this.eatContextual("as")) { + node.local = this.parseIdent(); + } else { + this.checkUnreserved(node.imported); + node.local = node.imported; + } + this.checkLValSimple(node.local, BIND_LEXICAL); + + return this.finishNode(node, "ImportSpecifier") + }; + + pp$8.parseImportDefaultSpecifier = function() { + // import defaultObj, { x, y as z } from '...' + var node = this.startNode(); + node.local = this.parseIdent(); + this.checkLValSimple(node.local, BIND_LEXICAL); + return this.finishNode(node, "ImportDefaultSpecifier") + }; + + pp$8.parseImportNamespaceSpecifier = function() { + var node = this.startNode(); + this.next(); + this.expectContextual("as"); + node.local = this.parseIdent(); + this.checkLValSimple(node.local, BIND_LEXICAL); + return this.finishNode(node, "ImportNamespaceSpecifier") + }; + + pp$8.parseImportSpecifiers = function() { + var nodes = [], first = true; + if (this.type === types$1.name) { + nodes.push(this.parseImportDefaultSpecifier()); + if (!this.eat(types$1.comma)) { return nodes } + } + if (this.type === types$1.star) { + nodes.push(this.parseImportNamespaceSpecifier()); + return nodes + } + this.expect(types$1.braceL); + while (!this.eat(types$1.braceR)) { + if (!first) { + this.expect(types$1.comma); + if (this.afterTrailingComma(types$1.braceR)) { break } + } else { first = false; } + + nodes.push(this.parseImportSpecifier()); + } + return nodes + }; + + pp$8.parseWithClause = function() { + var nodes = []; + if (!this.eat(types$1._with)) { + return nodes + } + this.expect(types$1.braceL); + var attributeKeys = {}; + var first = true; + while (!this.eat(types$1.braceR)) { + if (!first) { + this.expect(types$1.comma); + if (this.afterTrailingComma(types$1.braceR)) { break } + } else { first = false; } + + var attr = this.parseImportAttribute(); + var keyName = attr.key.type === "Identifier" ? attr.key.name : attr.key.value; + if (hasOwn(attributeKeys, keyName)) + { this.raiseRecoverable(attr.key.start, "Duplicate attribute key '" + keyName + "'"); } + attributeKeys[keyName] = true; + nodes.push(attr); + } + return nodes + }; + + pp$8.parseImportAttribute = function() { + var node = this.startNode(); + node.key = this.type === types$1.string ? this.parseExprAtom() : this.parseIdent(this.options.allowReserved !== "never"); + this.expect(types$1.colon); + if (this.type !== types$1.string) { + this.unexpected(); + } + node.value = this.parseExprAtom(); + return this.finishNode(node, "ImportAttribute") + }; + + pp$8.parseModuleExportName = function() { + if (this.options.ecmaVersion >= 13 && this.type === types$1.string) { + var stringLiteral = this.parseLiteral(this.value); + if (loneSurrogate.test(stringLiteral.value)) { + this.raise(stringLiteral.start, "An export name cannot include a lone surrogate."); + } + return stringLiteral + } + return this.parseIdent(true) + }; + + // Set `ExpressionStatement#directive` property for directive prologues. + pp$8.adaptDirectivePrologue = function(statements) { + for (var i = 0; i < statements.length && this.isDirectiveCandidate(statements[i]); ++i) { + statements[i].directive = statements[i].expression.raw.slice(1, -1); + } + }; + pp$8.isDirectiveCandidate = function(statement) { + return ( + this.options.ecmaVersion >= 5 && + statement.type === "ExpressionStatement" && + statement.expression.type === "Literal" && + typeof statement.expression.value === "string" && + // Reject parenthesized strings. + (this.input[statement.start] === "\"" || this.input[statement.start] === "'") + ) + }; + + var pp$7 = Parser.prototype; + + // Convert existing expression atom to assignable pattern + // if possible. + + pp$7.toAssignable = function(node, isBinding, refDestructuringErrors) { + if (this.options.ecmaVersion >= 6 && node) { + switch (node.type) { + case "Identifier": + if (this.inAsync && node.name === "await") + { this.raise(node.start, "Cannot use 'await' as identifier inside an async function"); } + break + + case "ObjectPattern": + case "ArrayPattern": + case "AssignmentPattern": + case "RestElement": + break + + case "ObjectExpression": + node.type = "ObjectPattern"; + if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); } + for (var i = 0, list = node.properties; i < list.length; i += 1) { + var prop = list[i]; + + this.toAssignable(prop, isBinding); + // Early error: + // AssignmentRestProperty[Yield, Await] : + // `...` DestructuringAssignmentTarget[Yield, Await] + // + // It is a Syntax Error if |DestructuringAssignmentTarget| is an |ArrayLiteral| or an |ObjectLiteral|. + if ( + prop.type === "RestElement" && + (prop.argument.type === "ArrayPattern" || prop.argument.type === "ObjectPattern") + ) { + this.raise(prop.argument.start, "Unexpected token"); + } + } + break + + case "Property": + // AssignmentProperty has type === "Property" + if (node.kind !== "init") { this.raise(node.key.start, "Object pattern can't contain getter or setter"); } + this.toAssignable(node.value, isBinding); + break + + case "ArrayExpression": + node.type = "ArrayPattern"; + if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); } + this.toAssignableList(node.elements, isBinding); + break + + case "SpreadElement": + node.type = "RestElement"; + this.toAssignable(node.argument, isBinding); + if (node.argument.type === "AssignmentPattern") + { this.raise(node.argument.start, "Rest elements cannot have a default value"); } + break + + case "AssignmentExpression": + if (node.operator !== "=") { this.raise(node.left.end, "Only '=' operator can be used for specifying default value."); } + node.type = "AssignmentPattern"; + delete node.operator; + this.toAssignable(node.left, isBinding); + break + + case "ParenthesizedExpression": + this.toAssignable(node.expression, isBinding, refDestructuringErrors); + break + + case "ChainExpression": + this.raiseRecoverable(node.start, "Optional chaining cannot appear in left-hand side"); + break + + case "MemberExpression": + if (!isBinding) { break } + + default: + this.raise(node.start, "Assigning to rvalue"); + } + } else if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); } + return node + }; + + // Convert list of expression atoms to binding list. + + pp$7.toAssignableList = function(exprList, isBinding) { + var end = exprList.length; + for (var i = 0; i < end; i++) { + var elt = exprList[i]; + if (elt) { this.toAssignable(elt, isBinding); } + } + if (end) { + var last = exprList[end - 1]; + if (this.options.ecmaVersion === 6 && isBinding && last && last.type === "RestElement" && last.argument.type !== "Identifier") + { this.unexpected(last.argument.start); } + } + return exprList + }; + + // Parses spread element. + + pp$7.parseSpread = function(refDestructuringErrors) { + var node = this.startNode(); + this.next(); + node.argument = this.parseMaybeAssign(false, refDestructuringErrors); + return this.finishNode(node, "SpreadElement") + }; + + pp$7.parseRestBinding = function() { + var node = this.startNode(); + this.next(); + + // RestElement inside of a function parameter must be an identifier + if (this.options.ecmaVersion === 6 && this.type !== types$1.name) + { this.unexpected(); } + + node.argument = this.parseBindingAtom(); + + return this.finishNode(node, "RestElement") + }; + + // Parses lvalue (assignable) atom. + + pp$7.parseBindingAtom = function() { + if (this.options.ecmaVersion >= 6) { + switch (this.type) { + case types$1.bracketL: + var node = this.startNode(); + this.next(); + node.elements = this.parseBindingList(types$1.bracketR, true, true); + return this.finishNode(node, "ArrayPattern") + + case types$1.braceL: + return this.parseObj(true) + } + } + return this.parseIdent() + }; + + pp$7.parseBindingList = function(close, allowEmpty, allowTrailingComma, allowModifiers) { + var elts = [], first = true; + while (!this.eat(close)) { + if (first) { first = false; } + else { this.expect(types$1.comma); } + if (allowEmpty && this.type === types$1.comma) { + elts.push(null); + } else if (allowTrailingComma && this.afterTrailingComma(close)) { + break + } else if (this.type === types$1.ellipsis) { + var rest = this.parseRestBinding(); + this.parseBindingListItem(rest); + elts.push(rest); + if (this.type === types$1.comma) { this.raiseRecoverable(this.start, "Comma is not permitted after the rest element"); } + this.expect(close); + break + } else { + elts.push(this.parseAssignableListItem(allowModifiers)); + } + } + return elts + }; + + pp$7.parseAssignableListItem = function(allowModifiers) { + var elem = this.parseMaybeDefault(this.start, this.startLoc); + this.parseBindingListItem(elem); + return elem + }; + + pp$7.parseBindingListItem = function(param) { + return param + }; + + // Parses assignment pattern around given atom if possible. + + pp$7.parseMaybeDefault = function(startPos, startLoc, left) { + left = left || this.parseBindingAtom(); + if (this.options.ecmaVersion < 6 || !this.eat(types$1.eq)) { return left } + var node = this.startNodeAt(startPos, startLoc); + node.left = left; + node.right = this.parseMaybeAssign(); + return this.finishNode(node, "AssignmentPattern") + }; + + // The following three functions all verify that a node is an lvalue — + // something that can be bound, or assigned to. In order to do so, they perform + // a variety of checks: + // + // - Check that none of the bound/assigned-to identifiers are reserved words. + // - Record name declarations for bindings in the appropriate scope. + // - Check duplicate argument names, if checkClashes is set. + // + // If a complex binding pattern is encountered (e.g., object and array + // destructuring), the entire pattern is recursively checked. + // + // There are three versions of checkLVal*() appropriate for different + // circumstances: + // + // - checkLValSimple() shall be used if the syntactic construct supports + // nothing other than identifiers and member expressions. Parenthesized + // expressions are also correctly handled. This is generally appropriate for + // constructs for which the spec says + // + // > It is a Syntax Error if AssignmentTargetType of [the production] is not + // > simple. + // + // It is also appropriate for checking if an identifier is valid and not + // defined elsewhere, like import declarations or function/class identifiers. + // + // Examples where this is used include: + // a += …; + // import a from '…'; + // where a is the node to be checked. + // + // - checkLValPattern() shall be used if the syntactic construct supports + // anything checkLValSimple() supports, as well as object and array + // destructuring patterns. This is generally appropriate for constructs for + // which the spec says + // + // > It is a Syntax Error if [the production] is neither an ObjectLiteral nor + // > an ArrayLiteral and AssignmentTargetType of [the production] is not + // > simple. + // + // Examples where this is used include: + // (a = …); + // const a = …; + // try { … } catch (a) { … } + // where a is the node to be checked. + // + // - checkLValInnerPattern() shall be used if the syntactic construct supports + // anything checkLValPattern() supports, as well as default assignment + // patterns, rest elements, and other constructs that may appear within an + // object or array destructuring pattern. + // + // As a special case, function parameters also use checkLValInnerPattern(), + // as they also support defaults and rest constructs. + // + // These functions deliberately support both assignment and binding constructs, + // as the logic for both is exceedingly similar. If the node is the target of + // an assignment, then bindingType should be set to BIND_NONE. Otherwise, it + // should be set to the appropriate BIND_* constant, like BIND_VAR or + // BIND_LEXICAL. + // + // If the function is called with a non-BIND_NONE bindingType, then + // additionally a checkClashes object may be specified to allow checking for + // duplicate argument names. checkClashes is ignored if the provided construct + // is an assignment (i.e., bindingType is BIND_NONE). + + pp$7.checkLValSimple = function(expr, bindingType, checkClashes) { + if ( bindingType === void 0 ) bindingType = BIND_NONE; + + var isBind = bindingType !== BIND_NONE; + + switch (expr.type) { + case "Identifier": + if (this.strict && this.reservedWordsStrictBind.test(expr.name)) + { this.raiseRecoverable(expr.start, (isBind ? "Binding " : "Assigning to ") + expr.name + " in strict mode"); } + if (isBind) { + if (bindingType === BIND_LEXICAL && expr.name === "let") + { this.raiseRecoverable(expr.start, "let is disallowed as a lexically bound name"); } + if (checkClashes) { + if (hasOwn(checkClashes, expr.name)) + { this.raiseRecoverable(expr.start, "Argument name clash"); } + checkClashes[expr.name] = true; + } + if (bindingType !== BIND_OUTSIDE) { this.declareName(expr.name, bindingType, expr.start); } + } + break + + case "ChainExpression": + this.raiseRecoverable(expr.start, "Optional chaining cannot appear in left-hand side"); + break + + case "MemberExpression": + if (isBind) { this.raiseRecoverable(expr.start, "Binding member expression"); } + break + + case "ParenthesizedExpression": + if (isBind) { this.raiseRecoverable(expr.start, "Binding parenthesized expression"); } + return this.checkLValSimple(expr.expression, bindingType, checkClashes) + + default: + this.raise(expr.start, (isBind ? "Binding" : "Assigning to") + " rvalue"); + } + }; + + pp$7.checkLValPattern = function(expr, bindingType, checkClashes) { + if ( bindingType === void 0 ) bindingType = BIND_NONE; + + switch (expr.type) { + case "ObjectPattern": + for (var i = 0, list = expr.properties; i < list.length; i += 1) { + var prop = list[i]; + + this.checkLValInnerPattern(prop, bindingType, checkClashes); + } + break + + case "ArrayPattern": + for (var i$1 = 0, list$1 = expr.elements; i$1 < list$1.length; i$1 += 1) { + var elem = list$1[i$1]; + + if (elem) { this.checkLValInnerPattern(elem, bindingType, checkClashes); } + } + break + + default: + this.checkLValSimple(expr, bindingType, checkClashes); + } + }; + + pp$7.checkLValInnerPattern = function(expr, bindingType, checkClashes) { + if ( bindingType === void 0 ) bindingType = BIND_NONE; + + switch (expr.type) { + case "Property": + // AssignmentProperty has type === "Property" + this.checkLValInnerPattern(expr.value, bindingType, checkClashes); + break + + case "AssignmentPattern": + this.checkLValPattern(expr.left, bindingType, checkClashes); + break + + case "RestElement": + this.checkLValPattern(expr.argument, bindingType, checkClashes); + break + + default: + this.checkLValPattern(expr, bindingType, checkClashes); + } + }; + + // The algorithm used to determine whether a regexp can appear at a + // given point in the program is loosely based on sweet.js' approach. + // See https://github.com/mozilla/sweet.js/wiki/design + + + var TokContext = function TokContext(token, isExpr, preserveSpace, override, generator) { + this.token = token; + this.isExpr = !!isExpr; + this.preserveSpace = !!preserveSpace; + this.override = override; + this.generator = !!generator; + }; + + var types = { + b_stat: new TokContext("{", false), + b_expr: new TokContext("{", true), + b_tmpl: new TokContext("${", false), + p_stat: new TokContext("(", false), + p_expr: new TokContext("(", true), + q_tmpl: new TokContext("`", true, true, function (p) { return p.tryReadTemplateToken(); }), + f_stat: new TokContext("function", false), + f_expr: new TokContext("function", true), + f_expr_gen: new TokContext("function", true, false, null, true), + f_gen: new TokContext("function", false, false, null, true) + }; + + var pp$6 = Parser.prototype; + + pp$6.initialContext = function() { + return [types.b_stat] + }; + + pp$6.curContext = function() { + return this.context[this.context.length - 1] + }; + + pp$6.braceIsBlock = function(prevType) { + var parent = this.curContext(); + if (parent === types.f_expr || parent === types.f_stat) + { return true } + if (prevType === types$1.colon && (parent === types.b_stat || parent === types.b_expr)) + { return !parent.isExpr } + + // The check for `tt.name && exprAllowed` detects whether we are + // after a `yield` or `of` construct. See the `updateContext` for + // `tt.name`. + if (prevType === types$1._return || prevType === types$1.name && this.exprAllowed) + { return lineBreak.test(this.input.slice(this.lastTokEnd, this.start)) } + if (prevType === types$1._else || prevType === types$1.semi || prevType === types$1.eof || prevType === types$1.parenR || prevType === types$1.arrow) + { return true } + if (prevType === types$1.braceL) + { return parent === types.b_stat } + if (prevType === types$1._var || prevType === types$1._const || prevType === types$1.name) + { return false } + return !this.exprAllowed + }; + + pp$6.inGeneratorContext = function() { + for (var i = this.context.length - 1; i >= 1; i--) { + var context = this.context[i]; + if (context.token === "function") + { return context.generator } + } + return false + }; + + pp$6.updateContext = function(prevType) { + var update, type = this.type; + if (type.keyword && prevType === types$1.dot) + { this.exprAllowed = false; } + else if (update = type.updateContext) + { update.call(this, prevType); } + else + { this.exprAllowed = type.beforeExpr; } + }; + + // Used to handle edge cases when token context could not be inferred correctly during tokenization phase + + pp$6.overrideContext = function(tokenCtx) { + if (this.curContext() !== tokenCtx) { + this.context[this.context.length - 1] = tokenCtx; + } + }; + + // Token-specific context update code + + types$1.parenR.updateContext = types$1.braceR.updateContext = function() { + if (this.context.length === 1) { + this.exprAllowed = true; + return + } + var out = this.context.pop(); + if (out === types.b_stat && this.curContext().token === "function") { + out = this.context.pop(); + } + this.exprAllowed = !out.isExpr; + }; + + types$1.braceL.updateContext = function(prevType) { + this.context.push(this.braceIsBlock(prevType) ? types.b_stat : types.b_expr); + this.exprAllowed = true; + }; + + types$1.dollarBraceL.updateContext = function() { + this.context.push(types.b_tmpl); + this.exprAllowed = true; + }; + + types$1.parenL.updateContext = function(prevType) { + var statementParens = prevType === types$1._if || prevType === types$1._for || prevType === types$1._with || prevType === types$1._while; + this.context.push(statementParens ? types.p_stat : types.p_expr); + this.exprAllowed = true; + }; + + types$1.incDec.updateContext = function() { + // tokExprAllowed stays unchanged + }; + + types$1._function.updateContext = types$1._class.updateContext = function(prevType) { + if (prevType.beforeExpr && prevType !== types$1._else && + !(prevType === types$1.semi && this.curContext() !== types.p_stat) && + !(prevType === types$1._return && lineBreak.test(this.input.slice(this.lastTokEnd, this.start))) && + !((prevType === types$1.colon || prevType === types$1.braceL) && this.curContext() === types.b_stat)) + { this.context.push(types.f_expr); } + else + { this.context.push(types.f_stat); } + this.exprAllowed = false; + }; + + types$1.colon.updateContext = function() { + if (this.curContext().token === "function") { this.context.pop(); } + this.exprAllowed = true; + }; + + types$1.backQuote.updateContext = function() { + if (this.curContext() === types.q_tmpl) + { this.context.pop(); } + else + { this.context.push(types.q_tmpl); } + this.exprAllowed = false; + }; + + types$1.star.updateContext = function(prevType) { + if (prevType === types$1._function) { + var index = this.context.length - 1; + if (this.context[index] === types.f_expr) + { this.context[index] = types.f_expr_gen; } + else + { this.context[index] = types.f_gen; } + } + this.exprAllowed = true; + }; + + types$1.name.updateContext = function(prevType) { + var allowed = false; + if (this.options.ecmaVersion >= 6 && prevType !== types$1.dot) { + if (this.value === "of" && !this.exprAllowed || + this.value === "yield" && this.inGeneratorContext()) + { allowed = true; } + } + this.exprAllowed = allowed; + }; + + // A recursive descent parser operates by defining functions for all + // syntactic elements, and recursively calling those, each function + // advancing the input stream and returning an AST node. Precedence + // of constructs (for example, the fact that `!x[1]` means `!(x[1])` + // instead of `(!x)[1]` is handled by the fact that the parser + // function that parses unary prefix operators is called first, and + // in turn calls the function that parses `[]` subscripts — that + // way, it'll receive the node for `x[1]` already parsed, and wraps + // *that* in the unary operator node. + // + // Acorn uses an [operator precedence parser][opp] to handle binary + // operator precedence, because it is much more compact than using + // the technique outlined above, which uses different, nesting + // functions to specify precedence, for all of the ten binary + // precedence levels that JavaScript defines. + // + // [opp]: http://en.wikipedia.org/wiki/Operator-precedence_parser + + + var pp$5 = Parser.prototype; + + // Check if property name clashes with already added. + // Object/class getters and setters are not allowed to clash — + // either with each other or with an init property — and in + // strict mode, init properties are also not allowed to be repeated. + + pp$5.checkPropClash = function(prop, propHash, refDestructuringErrors) { + if (this.options.ecmaVersion >= 9 && prop.type === "SpreadElement") + { return } + if (this.options.ecmaVersion >= 6 && (prop.computed || prop.method || prop.shorthand)) + { return } + var key = prop.key; + var name; + switch (key.type) { + case "Identifier": name = key.name; break + case "Literal": name = String(key.value); break + default: return + } + var kind = prop.kind; + if (this.options.ecmaVersion >= 6) { + if (name === "__proto__" && kind === "init") { + if (propHash.proto) { + if (refDestructuringErrors) { + if (refDestructuringErrors.doubleProto < 0) { + refDestructuringErrors.doubleProto = key.start; + } + } else { + this.raiseRecoverable(key.start, "Redefinition of __proto__ property"); + } + } + propHash.proto = true; + } + return + } + name = "$" + name; + var other = propHash[name]; + if (other) { + var redefinition; + if (kind === "init") { + redefinition = this.strict && other.init || other.get || other.set; + } else { + redefinition = other.init || other[kind]; + } + if (redefinition) + { this.raiseRecoverable(key.start, "Redefinition of property"); } + } else { + other = propHash[name] = { + init: false, + get: false, + set: false + }; + } + other[kind] = true; + }; + + // ### Expression parsing + + // These nest, from the most general expression type at the top to + // 'atomic', nondivisible expression types at the bottom. Most of + // the functions will simply let the function(s) below them parse, + // and, *if* the syntactic construct they handle is present, wrap + // the AST node that the inner parser gave them in another node. + + // Parse a full expression. The optional arguments are used to + // forbid the `in` operator (in for loops initalization expressions) + // and provide reference for storing '=' operator inside shorthand + // property assignment in contexts where both object expression + // and object pattern might appear (so it's possible to raise + // delayed syntax error at correct position). + + pp$5.parseExpression = function(forInit, refDestructuringErrors) { + var startPos = this.start, startLoc = this.startLoc; + var expr = this.parseMaybeAssign(forInit, refDestructuringErrors); + if (this.type === types$1.comma) { + var node = this.startNodeAt(startPos, startLoc); + node.expressions = [expr]; + while (this.eat(types$1.comma)) { node.expressions.push(this.parseMaybeAssign(forInit, refDestructuringErrors)); } + return this.finishNode(node, "SequenceExpression") + } + return expr + }; + + // Parse an assignment expression. This includes applications of + // operators like `+=`. + + pp$5.parseMaybeAssign = function(forInit, refDestructuringErrors, afterLeftParse) { + if (this.isContextual("yield")) { + if (this.inGenerator) { return this.parseYield(forInit) } + // The tokenizer will assume an expression is allowed after + // `yield`, but this isn't that kind of yield + else { this.exprAllowed = false; } + } + + var ownDestructuringErrors = false, oldParenAssign = -1, oldTrailingComma = -1, oldDoubleProto = -1; + if (refDestructuringErrors) { + oldParenAssign = refDestructuringErrors.parenthesizedAssign; + oldTrailingComma = refDestructuringErrors.trailingComma; + oldDoubleProto = refDestructuringErrors.doubleProto; + refDestructuringErrors.parenthesizedAssign = refDestructuringErrors.trailingComma = -1; + } else { + refDestructuringErrors = new DestructuringErrors; + ownDestructuringErrors = true; + } + + var startPos = this.start, startLoc = this.startLoc; + if (this.type === types$1.parenL || this.type === types$1.name) { + this.potentialArrowAt = this.start; + this.potentialArrowInForAwait = forInit === "await"; + } + var left = this.parseMaybeConditional(forInit, refDestructuringErrors); + if (afterLeftParse) { left = afterLeftParse.call(this, left, startPos, startLoc); } + if (this.type.isAssign) { + var node = this.startNodeAt(startPos, startLoc); + node.operator = this.value; + if (this.type === types$1.eq) + { left = this.toAssignable(left, false, refDestructuringErrors); } + if (!ownDestructuringErrors) { + refDestructuringErrors.parenthesizedAssign = refDestructuringErrors.trailingComma = refDestructuringErrors.doubleProto = -1; + } + if (refDestructuringErrors.shorthandAssign >= left.start) + { refDestructuringErrors.shorthandAssign = -1; } // reset because shorthand default was used correctly + if (this.type === types$1.eq) + { this.checkLValPattern(left); } + else + { this.checkLValSimple(left); } + node.left = left; + this.next(); + node.right = this.parseMaybeAssign(forInit); + if (oldDoubleProto > -1) { refDestructuringErrors.doubleProto = oldDoubleProto; } + return this.finishNode(node, "AssignmentExpression") + } else { + if (ownDestructuringErrors) { this.checkExpressionErrors(refDestructuringErrors, true); } + } + if (oldParenAssign > -1) { refDestructuringErrors.parenthesizedAssign = oldParenAssign; } + if (oldTrailingComma > -1) { refDestructuringErrors.trailingComma = oldTrailingComma; } + return left + }; + + // Parse a ternary conditional (`?:`) operator. + + pp$5.parseMaybeConditional = function(forInit, refDestructuringErrors) { + var startPos = this.start, startLoc = this.startLoc; + var expr = this.parseExprOps(forInit, refDestructuringErrors); + if (this.checkExpressionErrors(refDestructuringErrors)) { return expr } + if (this.eat(types$1.question)) { + var node = this.startNodeAt(startPos, startLoc); + node.test = expr; + node.consequent = this.parseMaybeAssign(); + this.expect(types$1.colon); + node.alternate = this.parseMaybeAssign(forInit); + return this.finishNode(node, "ConditionalExpression") + } + return expr + }; + + // Start the precedence parser. + + pp$5.parseExprOps = function(forInit, refDestructuringErrors) { + var startPos = this.start, startLoc = this.startLoc; + var expr = this.parseMaybeUnary(refDestructuringErrors, false, false, forInit); + if (this.checkExpressionErrors(refDestructuringErrors)) { return expr } + return expr.start === startPos && expr.type === "ArrowFunctionExpression" ? expr : this.parseExprOp(expr, startPos, startLoc, -1, forInit) + }; + + // Parse binary operators with the operator precedence parsing + // algorithm. `left` is the left-hand side of the operator. + // `minPrec` provides context that allows the function to stop and + // defer further parser to one of its callers when it encounters an + // operator that has a lower precedence than the set it is parsing. + + pp$5.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, forInit) { + var prec = this.type.binop; + if (prec != null && (!forInit || this.type !== types$1._in)) { + if (prec > minPrec) { + var logical = this.type === types$1.logicalOR || this.type === types$1.logicalAND; + var coalesce = this.type === types$1.coalesce; + if (coalesce) { + // Handle the precedence of `tt.coalesce` as equal to the range of logical expressions. + // In other words, `node.right` shouldn't contain logical expressions in order to check the mixed error. + prec = types$1.logicalAND.binop; + } + var op = this.value; + this.next(); + var startPos = this.start, startLoc = this.startLoc; + var right = this.parseExprOp(this.parseMaybeUnary(null, false, false, forInit), startPos, startLoc, prec, forInit); + var node = this.buildBinary(leftStartPos, leftStartLoc, left, right, op, logical || coalesce); + if ((logical && this.type === types$1.coalesce) || (coalesce && (this.type === types$1.logicalOR || this.type === types$1.logicalAND))) { + this.raiseRecoverable(this.start, "Logical expressions and coalesce expressions cannot be mixed. Wrap either by parentheses"); + } + return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, forInit) + } + } + return left + }; + + pp$5.buildBinary = function(startPos, startLoc, left, right, op, logical) { + if (right.type === "PrivateIdentifier") { this.raise(right.start, "Private identifier can only be left side of binary expression"); } + var node = this.startNodeAt(startPos, startLoc); + node.left = left; + node.operator = op; + node.right = right; + return this.finishNode(node, logical ? "LogicalExpression" : "BinaryExpression") + }; + + // Parse unary operators, both prefix and postfix. + + pp$5.parseMaybeUnary = function(refDestructuringErrors, sawUnary, incDec, forInit) { + var startPos = this.start, startLoc = this.startLoc, expr; + if (this.isContextual("await") && this.canAwait) { + expr = this.parseAwait(forInit); + sawUnary = true; + } else if (this.type.prefix) { + var node = this.startNode(), update = this.type === types$1.incDec; + node.operator = this.value; + node.prefix = true; + this.next(); + node.argument = this.parseMaybeUnary(null, true, update, forInit); + this.checkExpressionErrors(refDestructuringErrors, true); + if (update) { this.checkLValSimple(node.argument); } + else if (this.strict && node.operator === "delete" && isLocalVariableAccess(node.argument)) + { this.raiseRecoverable(node.start, "Deleting local variable in strict mode"); } + else if (node.operator === "delete" && isPrivateFieldAccess(node.argument)) + { this.raiseRecoverable(node.start, "Private fields can not be deleted"); } + else { sawUnary = true; } + expr = this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression"); + } else if (!sawUnary && this.type === types$1.privateId) { + if ((forInit || this.privateNameStack.length === 0) && this.options.checkPrivateFields) { this.unexpected(); } + expr = this.parsePrivateIdent(); + // only could be private fields in 'in', such as #x in obj + if (this.type !== types$1._in) { this.unexpected(); } + } else { + expr = this.parseExprSubscripts(refDestructuringErrors, forInit); + if (this.checkExpressionErrors(refDestructuringErrors)) { return expr } + while (this.type.postfix && !this.canInsertSemicolon()) { + var node$1 = this.startNodeAt(startPos, startLoc); + node$1.operator = this.value; + node$1.prefix = false; + node$1.argument = expr; + this.checkLValSimple(expr); + this.next(); + expr = this.finishNode(node$1, "UpdateExpression"); + } + } + + if (!incDec && this.eat(types$1.starstar)) { + if (sawUnary) + { this.unexpected(this.lastTokStart); } + else + { return this.buildBinary(startPos, startLoc, expr, this.parseMaybeUnary(null, false, false, forInit), "**", false) } + } else { + return expr + } + }; + + function isLocalVariableAccess(node) { + return ( + node.type === "Identifier" || + node.type === "ParenthesizedExpression" && isLocalVariableAccess(node.expression) + ) + } + + function isPrivateFieldAccess(node) { + return ( + node.type === "MemberExpression" && node.property.type === "PrivateIdentifier" || + node.type === "ChainExpression" && isPrivateFieldAccess(node.expression) || + node.type === "ParenthesizedExpression" && isPrivateFieldAccess(node.expression) + ) + } + + // Parse call, dot, and `[]`-subscript expressions. + + pp$5.parseExprSubscripts = function(refDestructuringErrors, forInit) { + var startPos = this.start, startLoc = this.startLoc; + var expr = this.parseExprAtom(refDestructuringErrors, forInit); + if (expr.type === "ArrowFunctionExpression" && this.input.slice(this.lastTokStart, this.lastTokEnd) !== ")") + { return expr } + var result = this.parseSubscripts(expr, startPos, startLoc, false, forInit); + if (refDestructuringErrors && result.type === "MemberExpression") { + if (refDestructuringErrors.parenthesizedAssign >= result.start) { refDestructuringErrors.parenthesizedAssign = -1; } + if (refDestructuringErrors.parenthesizedBind >= result.start) { refDestructuringErrors.parenthesizedBind = -1; } + if (refDestructuringErrors.trailingComma >= result.start) { refDestructuringErrors.trailingComma = -1; } + } + return result + }; + + pp$5.parseSubscripts = function(base, startPos, startLoc, noCalls, forInit) { + var maybeAsyncArrow = this.options.ecmaVersion >= 8 && base.type === "Identifier" && base.name === "async" && + this.lastTokEnd === base.end && !this.canInsertSemicolon() && base.end - base.start === 5 && + this.potentialArrowAt === base.start; + var optionalChained = false; + + while (true) { + var element = this.parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit); + + if (element.optional) { optionalChained = true; } + if (element === base || element.type === "ArrowFunctionExpression") { + if (optionalChained) { + var chainNode = this.startNodeAt(startPos, startLoc); + chainNode.expression = element; + element = this.finishNode(chainNode, "ChainExpression"); + } + return element + } + + base = element; + } + }; + + pp$5.shouldParseAsyncArrow = function() { + return !this.canInsertSemicolon() && this.eat(types$1.arrow) + }; + + pp$5.parseSubscriptAsyncArrow = function(startPos, startLoc, exprList, forInit) { + return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList, true, forInit) + }; + + pp$5.parseSubscript = function(base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit) { + var optionalSupported = this.options.ecmaVersion >= 11; + var optional = optionalSupported && this.eat(types$1.questionDot); + if (noCalls && optional) { this.raise(this.lastTokStart, "Optional chaining cannot appear in the callee of new expressions"); } + + var computed = this.eat(types$1.bracketL); + if (computed || (optional && this.type !== types$1.parenL && this.type !== types$1.backQuote) || this.eat(types$1.dot)) { + var node = this.startNodeAt(startPos, startLoc); + node.object = base; + if (computed) { + node.property = this.parseExpression(); + this.expect(types$1.bracketR); + } else if (this.type === types$1.privateId && base.type !== "Super") { + node.property = this.parsePrivateIdent(); + } else { + node.property = this.parseIdent(this.options.allowReserved !== "never"); + } + node.computed = !!computed; + if (optionalSupported) { + node.optional = optional; + } + base = this.finishNode(node, "MemberExpression"); + } else if (!noCalls && this.eat(types$1.parenL)) { + var refDestructuringErrors = new DestructuringErrors, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos; + this.yieldPos = 0; + this.awaitPos = 0; + this.awaitIdentPos = 0; + var exprList = this.parseExprList(types$1.parenR, this.options.ecmaVersion >= 8, false, refDestructuringErrors); + if (maybeAsyncArrow && !optional && this.shouldParseAsyncArrow()) { + this.checkPatternErrors(refDestructuringErrors, false); + this.checkYieldAwaitInDefaultParams(); + if (this.awaitIdentPos > 0) + { this.raise(this.awaitIdentPos, "Cannot use 'await' as identifier inside an async function"); } + this.yieldPos = oldYieldPos; + this.awaitPos = oldAwaitPos; + this.awaitIdentPos = oldAwaitIdentPos; + return this.parseSubscriptAsyncArrow(startPos, startLoc, exprList, forInit) + } + this.checkExpressionErrors(refDestructuringErrors, true); + this.yieldPos = oldYieldPos || this.yieldPos; + this.awaitPos = oldAwaitPos || this.awaitPos; + this.awaitIdentPos = oldAwaitIdentPos || this.awaitIdentPos; + var node$1 = this.startNodeAt(startPos, startLoc); + node$1.callee = base; + node$1.arguments = exprList; + if (optionalSupported) { + node$1.optional = optional; + } + base = this.finishNode(node$1, "CallExpression"); + } else if (this.type === types$1.backQuote) { + if (optional || optionalChained) { + this.raise(this.start, "Optional chaining cannot appear in the tag of tagged template expressions"); + } + var node$2 = this.startNodeAt(startPos, startLoc); + node$2.tag = base; + node$2.quasi = this.parseTemplate({isTagged: true}); + base = this.finishNode(node$2, "TaggedTemplateExpression"); + } + return base + }; + + // Parse an atomic expression — either a single token that is an + // expression, an expression started by a keyword like `function` or + // `new`, or an expression wrapped in punctuation like `()`, `[]`, + // or `{}`. + + pp$5.parseExprAtom = function(refDestructuringErrors, forInit, forNew) { + // If a division operator appears in an expression position, the + // tokenizer got confused, and we force it to read a regexp instead. + if (this.type === types$1.slash) { this.readRegexp(); } + + var node, canBeArrow = this.potentialArrowAt === this.start; + switch (this.type) { + case types$1._super: + if (!this.allowSuper) + { this.raise(this.start, "'super' keyword outside a method"); } + node = this.startNode(); + this.next(); + if (this.type === types$1.parenL && !this.allowDirectSuper) + { this.raise(node.start, "super() call outside constructor of a subclass"); } + // The `super` keyword can appear at below: + // SuperProperty: + // super [ Expression ] + // super . IdentifierName + // SuperCall: + // super ( Arguments ) + if (this.type !== types$1.dot && this.type !== types$1.bracketL && this.type !== types$1.parenL) + { this.unexpected(); } + return this.finishNode(node, "Super") + + case types$1._this: + node = this.startNode(); + this.next(); + return this.finishNode(node, "ThisExpression") + + case types$1.name: + var startPos = this.start, startLoc = this.startLoc, containsEsc = this.containsEsc; + var id = this.parseIdent(false); + if (this.options.ecmaVersion >= 8 && !containsEsc && id.name === "async" && !this.canInsertSemicolon() && this.eat(types$1._function)) { + this.overrideContext(types.f_expr); + return this.parseFunction(this.startNodeAt(startPos, startLoc), 0, false, true, forInit) + } + if (canBeArrow && !this.canInsertSemicolon()) { + if (this.eat(types$1.arrow)) + { return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], false, forInit) } + if (this.options.ecmaVersion >= 8 && id.name === "async" && this.type === types$1.name && !containsEsc && + (!this.potentialArrowInForAwait || this.value !== "of" || this.containsEsc)) { + id = this.parseIdent(false); + if (this.canInsertSemicolon() || !this.eat(types$1.arrow)) + { this.unexpected(); } + return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], true, forInit) + } + } + return id + + case types$1.regexp: + var value = this.value; + node = this.parseLiteral(value.value); + node.regex = {pattern: value.pattern, flags: value.flags}; + return node + + case types$1.num: case types$1.string: + return this.parseLiteral(this.value) + + case types$1._null: case types$1._true: case types$1._false: + node = this.startNode(); + node.value = this.type === types$1._null ? null : this.type === types$1._true; + node.raw = this.type.keyword; + this.next(); + return this.finishNode(node, "Literal") + + case types$1.parenL: + var start = this.start, expr = this.parseParenAndDistinguishExpression(canBeArrow, forInit); + if (refDestructuringErrors) { + if (refDestructuringErrors.parenthesizedAssign < 0 && !this.isSimpleAssignTarget(expr)) + { refDestructuringErrors.parenthesizedAssign = start; } + if (refDestructuringErrors.parenthesizedBind < 0) + { refDestructuringErrors.parenthesizedBind = start; } + } + return expr + + case types$1.bracketL: + node = this.startNode(); + this.next(); + node.elements = this.parseExprList(types$1.bracketR, true, true, refDestructuringErrors); + return this.finishNode(node, "ArrayExpression") + + case types$1.braceL: + this.overrideContext(types.b_expr); + return this.parseObj(false, refDestructuringErrors) + + case types$1._function: + node = this.startNode(); + this.next(); + return this.parseFunction(node, 0) + + case types$1._class: + return this.parseClass(this.startNode(), false) + + case types$1._new: + return this.parseNew() + + case types$1.backQuote: + return this.parseTemplate() + + case types$1._import: + if (this.options.ecmaVersion >= 11) { + return this.parseExprImport(forNew) + } else { + return this.unexpected() + } + + default: + return this.parseExprAtomDefault() + } + }; + + pp$5.parseExprAtomDefault = function() { + this.unexpected(); + }; + + pp$5.parseExprImport = function(forNew) { + var node = this.startNode(); + + // Consume `import` as an identifier for `import.meta`. + // Because `this.parseIdent(true)` doesn't check escape sequences, it needs the check of `this.containsEsc`. + if (this.containsEsc) { this.raiseRecoverable(this.start, "Escape sequence in keyword import"); } + this.next(); + + if (this.type === types$1.parenL && !forNew) { + return this.parseDynamicImport(node) + } else if (this.type === types$1.dot) { + var meta = this.startNodeAt(node.start, node.loc && node.loc.start); + meta.name = "import"; + node.meta = this.finishNode(meta, "Identifier"); + return this.parseImportMeta(node) + } else { + this.unexpected(); + } + }; + + pp$5.parseDynamicImport = function(node) { + this.next(); // skip `(` + + // Parse node.source. + node.source = this.parseMaybeAssign(); + + if (this.options.ecmaVersion >= 16) { + if (!this.eat(types$1.parenR)) { + this.expect(types$1.comma); + if (!this.afterTrailingComma(types$1.parenR)) { + node.options = this.parseMaybeAssign(); + if (!this.eat(types$1.parenR)) { + this.expect(types$1.comma); + if (!this.afterTrailingComma(types$1.parenR)) { + this.unexpected(); + } + } + } else { + node.options = null; + } + } else { + node.options = null; + } + } else { + // Verify ending. + if (!this.eat(types$1.parenR)) { + var errorPos = this.start; + if (this.eat(types$1.comma) && this.eat(types$1.parenR)) { + this.raiseRecoverable(errorPos, "Trailing comma is not allowed in import()"); + } else { + this.unexpected(errorPos); + } + } + } + + return this.finishNode(node, "ImportExpression") + }; + + pp$5.parseImportMeta = function(node) { + this.next(); // skip `.` + + var containsEsc = this.containsEsc; + node.property = this.parseIdent(true); + + if (node.property.name !== "meta") + { this.raiseRecoverable(node.property.start, "The only valid meta property for import is 'import.meta'"); } + if (containsEsc) + { this.raiseRecoverable(node.start, "'import.meta' must not contain escaped characters"); } + if (this.options.sourceType !== "module" && !this.options.allowImportExportEverywhere) + { this.raiseRecoverable(node.start, "Cannot use 'import.meta' outside a module"); } + + return this.finishNode(node, "MetaProperty") + }; + + pp$5.parseLiteral = function(value) { + var node = this.startNode(); + node.value = value; + node.raw = this.input.slice(this.start, this.end); + if (node.raw.charCodeAt(node.raw.length - 1) === 110) + { node.bigint = node.value != null ? node.value.toString() : node.raw.slice(0, -1).replace(/_/g, ""); } + this.next(); + return this.finishNode(node, "Literal") + }; + + pp$5.parseParenExpression = function() { + this.expect(types$1.parenL); + var val = this.parseExpression(); + this.expect(types$1.parenR); + return val + }; + + pp$5.shouldParseArrow = function(exprList) { + return !this.canInsertSemicolon() + }; + + pp$5.parseParenAndDistinguishExpression = function(canBeArrow, forInit) { + var startPos = this.start, startLoc = this.startLoc, val, allowTrailingComma = this.options.ecmaVersion >= 8; + if (this.options.ecmaVersion >= 6) { + this.next(); + + var innerStartPos = this.start, innerStartLoc = this.startLoc; + var exprList = [], first = true, lastIsComma = false; + var refDestructuringErrors = new DestructuringErrors, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, spreadStart; + this.yieldPos = 0; + this.awaitPos = 0; + // Do not save awaitIdentPos to allow checking awaits nested in parameters + while (this.type !== types$1.parenR) { + first ? first = false : this.expect(types$1.comma); + if (allowTrailingComma && this.afterTrailingComma(types$1.parenR, true)) { + lastIsComma = true; + break + } else if (this.type === types$1.ellipsis) { + spreadStart = this.start; + exprList.push(this.parseParenItem(this.parseRestBinding())); + if (this.type === types$1.comma) { + this.raiseRecoverable( + this.start, + "Comma is not permitted after the rest element" + ); + } + break + } else { + exprList.push(this.parseMaybeAssign(false, refDestructuringErrors, this.parseParenItem)); + } + } + var innerEndPos = this.lastTokEnd, innerEndLoc = this.lastTokEndLoc; + this.expect(types$1.parenR); + + if (canBeArrow && this.shouldParseArrow(exprList) && this.eat(types$1.arrow)) { + this.checkPatternErrors(refDestructuringErrors, false); + this.checkYieldAwaitInDefaultParams(); + this.yieldPos = oldYieldPos; + this.awaitPos = oldAwaitPos; + return this.parseParenArrowList(startPos, startLoc, exprList, forInit) + } + + if (!exprList.length || lastIsComma) { this.unexpected(this.lastTokStart); } + if (spreadStart) { this.unexpected(spreadStart); } + this.checkExpressionErrors(refDestructuringErrors, true); + this.yieldPos = oldYieldPos || this.yieldPos; + this.awaitPos = oldAwaitPos || this.awaitPos; + + if (exprList.length > 1) { + val = this.startNodeAt(innerStartPos, innerStartLoc); + val.expressions = exprList; + this.finishNodeAt(val, "SequenceExpression", innerEndPos, innerEndLoc); + } else { + val = exprList[0]; + } + } else { + val = this.parseParenExpression(); + } + + if (this.options.preserveParens) { + var par = this.startNodeAt(startPos, startLoc); + par.expression = val; + return this.finishNode(par, "ParenthesizedExpression") + } else { + return val + } + }; + + pp$5.parseParenItem = function(item) { + return item + }; + + pp$5.parseParenArrowList = function(startPos, startLoc, exprList, forInit) { + return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList, false, forInit) + }; + + // New's precedence is slightly tricky. It must allow its argument to + // be a `[]` or dot subscript expression, but not a call — at least, + // not without wrapping it in parentheses. Thus, it uses the noCalls + // argument to parseSubscripts to prevent it from consuming the + // argument list. + + var empty = []; + + pp$5.parseNew = function() { + if (this.containsEsc) { this.raiseRecoverable(this.start, "Escape sequence in keyword new"); } + var node = this.startNode(); + this.next(); + if (this.options.ecmaVersion >= 6 && this.type === types$1.dot) { + var meta = this.startNodeAt(node.start, node.loc && node.loc.start); + meta.name = "new"; + node.meta = this.finishNode(meta, "Identifier"); + this.next(); + var containsEsc = this.containsEsc; + node.property = this.parseIdent(true); + if (node.property.name !== "target") + { this.raiseRecoverable(node.property.start, "The only valid meta property for new is 'new.target'"); } + if (containsEsc) + { this.raiseRecoverable(node.start, "'new.target' must not contain escaped characters"); } + if (!this.allowNewDotTarget) + { this.raiseRecoverable(node.start, "'new.target' can only be used in functions and class static block"); } + return this.finishNode(node, "MetaProperty") + } + var startPos = this.start, startLoc = this.startLoc; + node.callee = this.parseSubscripts(this.parseExprAtom(null, false, true), startPos, startLoc, true, false); + if (this.eat(types$1.parenL)) { node.arguments = this.parseExprList(types$1.parenR, this.options.ecmaVersion >= 8, false); } + else { node.arguments = empty; } + return this.finishNode(node, "NewExpression") + }; + + // Parse template expression. + + pp$5.parseTemplateElement = function(ref) { + var isTagged = ref.isTagged; + + var elem = this.startNode(); + if (this.type === types$1.invalidTemplate) { + if (!isTagged) { + this.raiseRecoverable(this.start, "Bad escape sequence in untagged template literal"); + } + elem.value = { + raw: this.value.replace(/\r\n?/g, "\n"), + cooked: null + }; + } else { + elem.value = { + raw: this.input.slice(this.start, this.end).replace(/\r\n?/g, "\n"), + cooked: this.value + }; + } + this.next(); + elem.tail = this.type === types$1.backQuote; + return this.finishNode(elem, "TemplateElement") + }; + + pp$5.parseTemplate = function(ref) { + if ( ref === void 0 ) ref = {}; + var isTagged = ref.isTagged; if ( isTagged === void 0 ) isTagged = false; + + var node = this.startNode(); + this.next(); + node.expressions = []; + var curElt = this.parseTemplateElement({isTagged: isTagged}); + node.quasis = [curElt]; + while (!curElt.tail) { + if (this.type === types$1.eof) { this.raise(this.pos, "Unterminated template literal"); } + this.expect(types$1.dollarBraceL); + node.expressions.push(this.parseExpression()); + this.expect(types$1.braceR); + node.quasis.push(curElt = this.parseTemplateElement({isTagged: isTagged})); + } + this.next(); + return this.finishNode(node, "TemplateLiteral") + }; + + pp$5.isAsyncProp = function(prop) { + return !prop.computed && prop.key.type === "Identifier" && prop.key.name === "async" && + (this.type === types$1.name || this.type === types$1.num || this.type === types$1.string || this.type === types$1.bracketL || this.type.keyword || (this.options.ecmaVersion >= 9 && this.type === types$1.star)) && + !lineBreak.test(this.input.slice(this.lastTokEnd, this.start)) + }; + + // Parse an object literal or binding pattern. + + pp$5.parseObj = function(isPattern, refDestructuringErrors) { + var node = this.startNode(), first = true, propHash = {}; + node.properties = []; + this.next(); + while (!this.eat(types$1.braceR)) { + if (!first) { + this.expect(types$1.comma); + if (this.options.ecmaVersion >= 5 && this.afterTrailingComma(types$1.braceR)) { break } + } else { first = false; } + + var prop = this.parseProperty(isPattern, refDestructuringErrors); + if (!isPattern) { this.checkPropClash(prop, propHash, refDestructuringErrors); } + node.properties.push(prop); + } + return this.finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression") + }; + + pp$5.parseProperty = function(isPattern, refDestructuringErrors) { + var prop = this.startNode(), isGenerator, isAsync, startPos, startLoc; + if (this.options.ecmaVersion >= 9 && this.eat(types$1.ellipsis)) { + if (isPattern) { + prop.argument = this.parseIdent(false); + if (this.type === types$1.comma) { + this.raiseRecoverable(this.start, "Comma is not permitted after the rest element"); + } + return this.finishNode(prop, "RestElement") + } + // Parse argument. + prop.argument = this.parseMaybeAssign(false, refDestructuringErrors); + // To disallow trailing comma via `this.toAssignable()`. + if (this.type === types$1.comma && refDestructuringErrors && refDestructuringErrors.trailingComma < 0) { + refDestructuringErrors.trailingComma = this.start; + } + // Finish + return this.finishNode(prop, "SpreadElement") + } + if (this.options.ecmaVersion >= 6) { + prop.method = false; + prop.shorthand = false; + if (isPattern || refDestructuringErrors) { + startPos = this.start; + startLoc = this.startLoc; + } + if (!isPattern) + { isGenerator = this.eat(types$1.star); } + } + var containsEsc = this.containsEsc; + this.parsePropertyName(prop); + if (!isPattern && !containsEsc && this.options.ecmaVersion >= 8 && !isGenerator && this.isAsyncProp(prop)) { + isAsync = true; + isGenerator = this.options.ecmaVersion >= 9 && this.eat(types$1.star); + this.parsePropertyName(prop); + } else { + isAsync = false; + } + this.parsePropertyValue(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc); + return this.finishNode(prop, "Property") + }; + + pp$5.parseGetterSetter = function(prop) { + var kind = prop.key.name; + this.parsePropertyName(prop); + prop.value = this.parseMethod(false); + prop.kind = kind; + var paramCount = prop.kind === "get" ? 0 : 1; + if (prop.value.params.length !== paramCount) { + var start = prop.value.start; + if (prop.kind === "get") + { this.raiseRecoverable(start, "getter should have no params"); } + else + { this.raiseRecoverable(start, "setter should have exactly one param"); } + } else { + if (prop.kind === "set" && prop.value.params[0].type === "RestElement") + { this.raiseRecoverable(prop.value.params[0].start, "Setter cannot use rest params"); } + } + }; + + pp$5.parsePropertyValue = function(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc) { + if ((isGenerator || isAsync) && this.type === types$1.colon) + { this.unexpected(); } + + if (this.eat(types$1.colon)) { + prop.value = isPattern ? this.parseMaybeDefault(this.start, this.startLoc) : this.parseMaybeAssign(false, refDestructuringErrors); + prop.kind = "init"; + } else if (this.options.ecmaVersion >= 6 && this.type === types$1.parenL) { + if (isPattern) { this.unexpected(); } + prop.method = true; + prop.value = this.parseMethod(isGenerator, isAsync); + prop.kind = "init"; + } else if (!isPattern && !containsEsc && + this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === "Identifier" && + (prop.key.name === "get" || prop.key.name === "set") && + (this.type !== types$1.comma && this.type !== types$1.braceR && this.type !== types$1.eq)) { + if (isGenerator || isAsync) { this.unexpected(); } + this.parseGetterSetter(prop); + } else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === "Identifier") { + if (isGenerator || isAsync) { this.unexpected(); } + this.checkUnreserved(prop.key); + if (prop.key.name === "await" && !this.awaitIdentPos) + { this.awaitIdentPos = startPos; } + if (isPattern) { + prop.value = this.parseMaybeDefault(startPos, startLoc, this.copyNode(prop.key)); + } else if (this.type === types$1.eq && refDestructuringErrors) { + if (refDestructuringErrors.shorthandAssign < 0) + { refDestructuringErrors.shorthandAssign = this.start; } + prop.value = this.parseMaybeDefault(startPos, startLoc, this.copyNode(prop.key)); + } else { + prop.value = this.copyNode(prop.key); + } + prop.kind = "init"; + prop.shorthand = true; + } else { this.unexpected(); } + }; + + pp$5.parsePropertyName = function(prop) { + if (this.options.ecmaVersion >= 6) { + if (this.eat(types$1.bracketL)) { + prop.computed = true; + prop.key = this.parseMaybeAssign(); + this.expect(types$1.bracketR); + return prop.key + } else { + prop.computed = false; + } + } + return prop.key = this.type === types$1.num || this.type === types$1.string ? this.parseExprAtom() : this.parseIdent(this.options.allowReserved !== "never") + }; + + // Initialize empty function node. + + pp$5.initFunction = function(node) { + node.id = null; + if (this.options.ecmaVersion >= 6) { node.generator = node.expression = false; } + if (this.options.ecmaVersion >= 8) { node.async = false; } + }; + + // Parse object or class method. + + pp$5.parseMethod = function(isGenerator, isAsync, allowDirectSuper) { + var node = this.startNode(), oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos; + + this.initFunction(node); + if (this.options.ecmaVersion >= 6) + { node.generator = isGenerator; } + if (this.options.ecmaVersion >= 8) + { node.async = !!isAsync; } + + this.yieldPos = 0; + this.awaitPos = 0; + this.awaitIdentPos = 0; + this.enterScope(functionFlags(isAsync, node.generator) | SCOPE_SUPER | (allowDirectSuper ? SCOPE_DIRECT_SUPER : 0)); + + this.expect(types$1.parenL); + node.params = this.parseBindingList(types$1.parenR, false, this.options.ecmaVersion >= 8); + this.checkYieldAwaitInDefaultParams(); + this.parseFunctionBody(node, false, true, false); + + this.yieldPos = oldYieldPos; + this.awaitPos = oldAwaitPos; + this.awaitIdentPos = oldAwaitIdentPos; + return this.finishNode(node, "FunctionExpression") + }; + + // Parse arrow function expression with given parameters. + + pp$5.parseArrowExpression = function(node, params, isAsync, forInit) { + var oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos; + + this.enterScope(functionFlags(isAsync, false) | SCOPE_ARROW); + this.initFunction(node); + if (this.options.ecmaVersion >= 8) { node.async = !!isAsync; } + + this.yieldPos = 0; + this.awaitPos = 0; + this.awaitIdentPos = 0; + + node.params = this.toAssignableList(params, true); + this.parseFunctionBody(node, true, false, forInit); + + this.yieldPos = oldYieldPos; + this.awaitPos = oldAwaitPos; + this.awaitIdentPos = oldAwaitIdentPos; + return this.finishNode(node, "ArrowFunctionExpression") + }; + + // Parse function body and check parameters. + + pp$5.parseFunctionBody = function(node, isArrowFunction, isMethod, forInit) { + var isExpression = isArrowFunction && this.type !== types$1.braceL; + var oldStrict = this.strict, useStrict = false; + + if (isExpression) { + node.body = this.parseMaybeAssign(forInit); + node.expression = true; + this.checkParams(node, false); + } else { + var nonSimple = this.options.ecmaVersion >= 7 && !this.isSimpleParamList(node.params); + if (!oldStrict || nonSimple) { + useStrict = this.strictDirective(this.end); + // If this is a strict mode function, verify that argument names + // are not repeated, and it does not try to bind the words `eval` + // or `arguments`. + if (useStrict && nonSimple) + { this.raiseRecoverable(node.start, "Illegal 'use strict' directive in function with non-simple parameter list"); } + } + // Start a new scope with regard to labels and the `inFunction` + // flag (restore them to their old value afterwards). + var oldLabels = this.labels; + this.labels = []; + if (useStrict) { this.strict = true; } + + // Add the params to varDeclaredNames to ensure that an error is thrown + // if a let/const declaration in the function clashes with one of the params. + this.checkParams(node, !oldStrict && !useStrict && !isArrowFunction && !isMethod && this.isSimpleParamList(node.params)); + // Ensure the function name isn't a forbidden identifier in strict mode, e.g. 'eval' + if (this.strict && node.id) { this.checkLValSimple(node.id, BIND_OUTSIDE); } + node.body = this.parseBlock(false, undefined, useStrict && !oldStrict); + node.expression = false; + this.adaptDirectivePrologue(node.body.body); + this.labels = oldLabels; + } + this.exitScope(); + }; + + pp$5.isSimpleParamList = function(params) { + for (var i = 0, list = params; i < list.length; i += 1) + { + var param = list[i]; + + if (param.type !== "Identifier") { return false + } } + return true + }; + + // Checks function params for various disallowed patterns such as using "eval" + // or "arguments" and duplicate parameters. + + pp$5.checkParams = function(node, allowDuplicates) { + var nameHash = Object.create(null); + for (var i = 0, list = node.params; i < list.length; i += 1) + { + var param = list[i]; + + this.checkLValInnerPattern(param, BIND_VAR, allowDuplicates ? null : nameHash); + } + }; + + // Parses a comma-separated list of expressions, and returns them as + // an array. `close` is the token type that ends the list, and + // `allowEmpty` can be turned on to allow subsequent commas with + // nothing in between them to be parsed as `null` (which is needed + // for array literals). + + pp$5.parseExprList = function(close, allowTrailingComma, allowEmpty, refDestructuringErrors) { + var elts = [], first = true; + while (!this.eat(close)) { + if (!first) { + this.expect(types$1.comma); + if (allowTrailingComma && this.afterTrailingComma(close)) { break } + } else { first = false; } + + var elt = (void 0); + if (allowEmpty && this.type === types$1.comma) + { elt = null; } + else if (this.type === types$1.ellipsis) { + elt = this.parseSpread(refDestructuringErrors); + if (refDestructuringErrors && this.type === types$1.comma && refDestructuringErrors.trailingComma < 0) + { refDestructuringErrors.trailingComma = this.start; } + } else { + elt = this.parseMaybeAssign(false, refDestructuringErrors); + } + elts.push(elt); + } + return elts + }; + + pp$5.checkUnreserved = function(ref) { + var start = ref.start; + var end = ref.end; + var name = ref.name; + + if (this.inGenerator && name === "yield") + { this.raiseRecoverable(start, "Cannot use 'yield' as identifier inside a generator"); } + if (this.inAsync && name === "await") + { this.raiseRecoverable(start, "Cannot use 'await' as identifier inside an async function"); } + if (!(this.currentThisScope().flags & SCOPE_VAR) && name === "arguments") + { this.raiseRecoverable(start, "Cannot use 'arguments' in class field initializer"); } + if (this.inClassStaticBlock && (name === "arguments" || name === "await")) + { this.raise(start, ("Cannot use " + name + " in class static initialization block")); } + if (this.keywords.test(name)) + { this.raise(start, ("Unexpected keyword '" + name + "'")); } + if (this.options.ecmaVersion < 6 && + this.input.slice(start, end).indexOf("\\") !== -1) { return } + var re = this.strict ? this.reservedWordsStrict : this.reservedWords; + if (re.test(name)) { + if (!this.inAsync && name === "await") + { this.raiseRecoverable(start, "Cannot use keyword 'await' outside an async function"); } + this.raiseRecoverable(start, ("The keyword '" + name + "' is reserved")); + } + }; + + // Parse the next token as an identifier. If `liberal` is true (used + // when parsing properties), it will also convert keywords into + // identifiers. + + pp$5.parseIdent = function(liberal) { + var node = this.parseIdentNode(); + this.next(!!liberal); + this.finishNode(node, "Identifier"); + if (!liberal) { + this.checkUnreserved(node); + if (node.name === "await" && !this.awaitIdentPos) + { this.awaitIdentPos = node.start; } + } + return node + }; + + pp$5.parseIdentNode = function() { + var node = this.startNode(); + if (this.type === types$1.name) { + node.name = this.value; + } else if (this.type.keyword) { + node.name = this.type.keyword; + + // To fix https://github.com/acornjs/acorn/issues/575 + // `class` and `function` keywords push new context into this.context. + // But there is no chance to pop the context if the keyword is consumed as an identifier such as a property name. + // If the previous token is a dot, this does not apply because the context-managing code already ignored the keyword + if ((node.name === "class" || node.name === "function") && + (this.lastTokEnd !== this.lastTokStart + 1 || this.input.charCodeAt(this.lastTokStart) !== 46)) { + this.context.pop(); + } + this.type = types$1.name; + } else { + this.unexpected(); + } + return node + }; + + pp$5.parsePrivateIdent = function() { + var node = this.startNode(); + if (this.type === types$1.privateId) { + node.name = this.value; + } else { + this.unexpected(); + } + this.next(); + this.finishNode(node, "PrivateIdentifier"); + + // For validating existence + if (this.options.checkPrivateFields) { + if (this.privateNameStack.length === 0) { + this.raise(node.start, ("Private field '#" + (node.name) + "' must be declared in an enclosing class")); + } else { + this.privateNameStack[this.privateNameStack.length - 1].used.push(node); + } + } + + return node + }; + + // Parses yield expression inside generator. + + pp$5.parseYield = function(forInit) { + if (!this.yieldPos) { this.yieldPos = this.start; } + + var node = this.startNode(); + this.next(); + if (this.type === types$1.semi || this.canInsertSemicolon() || (this.type !== types$1.star && !this.type.startsExpr)) { + node.delegate = false; + node.argument = null; + } else { + node.delegate = this.eat(types$1.star); + node.argument = this.parseMaybeAssign(forInit); + } + return this.finishNode(node, "YieldExpression") + }; + + pp$5.parseAwait = function(forInit) { + if (!this.awaitPos) { this.awaitPos = this.start; } + + var node = this.startNode(); + this.next(); + node.argument = this.parseMaybeUnary(null, true, false, forInit); + return this.finishNode(node, "AwaitExpression") + }; + + var pp$4 = Parser.prototype; + + // This function is used to raise exceptions on parse errors. It + // takes an offset integer (into the current `input`) to indicate + // the location of the error, attaches the position to the end + // of the error message, and then raises a `SyntaxError` with that + // message. + + pp$4.raise = function(pos, message) { + var loc = getLineInfo(this.input, pos); + message += " (" + loc.line + ":" + loc.column + ")"; + if (this.sourceFile) { + message += " in " + this.sourceFile; + } + var err = new SyntaxError(message); + err.pos = pos; err.loc = loc; err.raisedAt = this.pos; + throw err + }; + + pp$4.raiseRecoverable = pp$4.raise; + + pp$4.curPosition = function() { + if (this.options.locations) { + return new Position(this.curLine, this.pos - this.lineStart) + } + }; + + var pp$3 = Parser.prototype; + + var Scope = function Scope(flags) { + this.flags = flags; + // A list of var-declared names in the current lexical scope + this.var = []; + // A list of lexically-declared names in the current lexical scope + this.lexical = []; + // A list of lexically-declared FunctionDeclaration names in the current lexical scope + this.functions = []; + }; + + // The functions in this module keep track of declared variables in the current scope in order to detect duplicate variable names. + + pp$3.enterScope = function(flags) { + this.scopeStack.push(new Scope(flags)); + }; + + pp$3.exitScope = function() { + this.scopeStack.pop(); + }; + + // The spec says: + // > At the top level of a function, or script, function declarations are + // > treated like var declarations rather than like lexical declarations. + pp$3.treatFunctionsAsVarInScope = function(scope) { + return (scope.flags & SCOPE_FUNCTION) || !this.inModule && (scope.flags & SCOPE_TOP) + }; + + pp$3.declareName = function(name, bindingType, pos) { + var redeclared = false; + if (bindingType === BIND_LEXICAL) { + var scope = this.currentScope(); + redeclared = scope.lexical.indexOf(name) > -1 || scope.functions.indexOf(name) > -1 || scope.var.indexOf(name) > -1; + scope.lexical.push(name); + if (this.inModule && (scope.flags & SCOPE_TOP)) + { delete this.undefinedExports[name]; } + } else if (bindingType === BIND_SIMPLE_CATCH) { + var scope$1 = this.currentScope(); + scope$1.lexical.push(name); + } else if (bindingType === BIND_FUNCTION) { + var scope$2 = this.currentScope(); + if (this.treatFunctionsAsVar) + { redeclared = scope$2.lexical.indexOf(name) > -1; } + else + { redeclared = scope$2.lexical.indexOf(name) > -1 || scope$2.var.indexOf(name) > -1; } + scope$2.functions.push(name); + } else { + for (var i = this.scopeStack.length - 1; i >= 0; --i) { + var scope$3 = this.scopeStack[i]; + if (scope$3.lexical.indexOf(name) > -1 && !((scope$3.flags & SCOPE_SIMPLE_CATCH) && scope$3.lexical[0] === name) || + !this.treatFunctionsAsVarInScope(scope$3) && scope$3.functions.indexOf(name) > -1) { + redeclared = true; + break + } + scope$3.var.push(name); + if (this.inModule && (scope$3.flags & SCOPE_TOP)) + { delete this.undefinedExports[name]; } + if (scope$3.flags & SCOPE_VAR) { break } + } + } + if (redeclared) { this.raiseRecoverable(pos, ("Identifier '" + name + "' has already been declared")); } + }; + + pp$3.checkLocalExport = function(id) { + // scope.functions must be empty as Module code is always strict. + if (this.scopeStack[0].lexical.indexOf(id.name) === -1 && + this.scopeStack[0].var.indexOf(id.name) === -1) { + this.undefinedExports[id.name] = id; + } + }; + + pp$3.currentScope = function() { + return this.scopeStack[this.scopeStack.length - 1] + }; + + pp$3.currentVarScope = function() { + for (var i = this.scopeStack.length - 1;; i--) { + var scope = this.scopeStack[i]; + if (scope.flags & (SCOPE_VAR | SCOPE_CLASS_FIELD_INIT | SCOPE_CLASS_STATIC_BLOCK)) { return scope } + } + }; + + // Could be useful for `this`, `new.target`, `super()`, `super.property`, and `super[property]`. + pp$3.currentThisScope = function() { + for (var i = this.scopeStack.length - 1;; i--) { + var scope = this.scopeStack[i]; + if (scope.flags & (SCOPE_VAR | SCOPE_CLASS_FIELD_INIT | SCOPE_CLASS_STATIC_BLOCK) && + !(scope.flags & SCOPE_ARROW)) { return scope } + } + }; + + var Node = function Node(parser, pos, loc) { + this.type = ""; + this.start = pos; + this.end = 0; + if (parser.options.locations) + { this.loc = new SourceLocation(parser, loc); } + if (parser.options.directSourceFile) + { this.sourceFile = parser.options.directSourceFile; } + if (parser.options.ranges) + { this.range = [pos, 0]; } + }; + + // Start an AST node, attaching a start offset. + + var pp$2 = Parser.prototype; + + pp$2.startNode = function() { + return new Node(this, this.start, this.startLoc) + }; + + pp$2.startNodeAt = function(pos, loc) { + return new Node(this, pos, loc) + }; + + // Finish an AST node, adding `type` and `end` properties. + + function finishNodeAt(node, type, pos, loc) { + node.type = type; + node.end = pos; + if (this.options.locations) + { node.loc.end = loc; } + if (this.options.ranges) + { node.range[1] = pos; } + return node + } + + pp$2.finishNode = function(node, type) { + return finishNodeAt.call(this, node, type, this.lastTokEnd, this.lastTokEndLoc) + }; + + // Finish node at given position + + pp$2.finishNodeAt = function(node, type, pos, loc) { + return finishNodeAt.call(this, node, type, pos, loc) + }; + + pp$2.copyNode = function(node) { + var newNode = new Node(this, node.start, this.startLoc); + for (var prop in node) { newNode[prop] = node[prop]; } + return newNode + }; + + // This file was generated by "bin/generate-unicode-script-values.js". Do not modify manually! + var scriptValuesAddedInUnicode = "Gara Garay Gukh Gurung_Khema Hrkt Katakana_Or_Hiragana Kawi Kirat_Rai Krai Nag_Mundari Nagm Ol_Onal Onao Sunu Sunuwar Todhri Todr Tulu_Tigalari Tutg Unknown Zzzz"; + + // This file contains Unicode properties extracted from the ECMAScript specification. + // The lists are extracted like so: + // $$('#table-binary-unicode-properties > figure > table > tbody > tr > td:nth-child(1) code').map(el => el.innerText) + + // #table-binary-unicode-properties + var ecma9BinaryProperties = "ASCII ASCII_Hex_Digit AHex Alphabetic Alpha Any Assigned Bidi_Control Bidi_C Bidi_Mirrored Bidi_M Case_Ignorable CI Cased Changes_When_Casefolded CWCF Changes_When_Casemapped CWCM Changes_When_Lowercased CWL Changes_When_NFKC_Casefolded CWKCF Changes_When_Titlecased CWT Changes_When_Uppercased CWU Dash Default_Ignorable_Code_Point DI Deprecated Dep Diacritic Dia Emoji Emoji_Component Emoji_Modifier Emoji_Modifier_Base Emoji_Presentation Extender Ext Grapheme_Base Gr_Base Grapheme_Extend Gr_Ext Hex_Digit Hex IDS_Binary_Operator IDSB IDS_Trinary_Operator IDST ID_Continue IDC ID_Start IDS Ideographic Ideo Join_Control Join_C Logical_Order_Exception LOE Lowercase Lower Math Noncharacter_Code_Point NChar Pattern_Syntax Pat_Syn Pattern_White_Space Pat_WS Quotation_Mark QMark Radical Regional_Indicator RI Sentence_Terminal STerm Soft_Dotted SD Terminal_Punctuation Term Unified_Ideograph UIdeo Uppercase Upper Variation_Selector VS White_Space space XID_Continue XIDC XID_Start XIDS"; + var ecma10BinaryProperties = ecma9BinaryProperties + " Extended_Pictographic"; + var ecma11BinaryProperties = ecma10BinaryProperties; + var ecma12BinaryProperties = ecma11BinaryProperties + " EBase EComp EMod EPres ExtPict"; + var ecma13BinaryProperties = ecma12BinaryProperties; + var ecma14BinaryProperties = ecma13BinaryProperties; + + var unicodeBinaryProperties = { + 9: ecma9BinaryProperties, + 10: ecma10BinaryProperties, + 11: ecma11BinaryProperties, + 12: ecma12BinaryProperties, + 13: ecma13BinaryProperties, + 14: ecma14BinaryProperties + }; + + // #table-binary-unicode-properties-of-strings + var ecma14BinaryPropertiesOfStrings = "Basic_Emoji Emoji_Keycap_Sequence RGI_Emoji_Modifier_Sequence RGI_Emoji_Flag_Sequence RGI_Emoji_Tag_Sequence RGI_Emoji_ZWJ_Sequence RGI_Emoji"; + + var unicodeBinaryPropertiesOfStrings = { + 9: "", + 10: "", + 11: "", + 12: "", + 13: "", + 14: ecma14BinaryPropertiesOfStrings + }; + + // #table-unicode-general-category-values + var unicodeGeneralCategoryValues = "Cased_Letter LC Close_Punctuation Pe Connector_Punctuation Pc Control Cc cntrl Currency_Symbol Sc Dash_Punctuation Pd Decimal_Number Nd digit Enclosing_Mark Me Final_Punctuation Pf Format Cf Initial_Punctuation Pi Letter L Letter_Number Nl Line_Separator Zl Lowercase_Letter Ll Mark M Combining_Mark Math_Symbol Sm Modifier_Letter Lm Modifier_Symbol Sk Nonspacing_Mark Mn Number N Open_Punctuation Ps Other C Other_Letter Lo Other_Number No Other_Punctuation Po Other_Symbol So Paragraph_Separator Zp Private_Use Co Punctuation P punct Separator Z Space_Separator Zs Spacing_Mark Mc Surrogate Cs Symbol S Titlecase_Letter Lt Unassigned Cn Uppercase_Letter Lu"; + + // #table-unicode-script-values + var ecma9ScriptValues = "Adlam Adlm Ahom Anatolian_Hieroglyphs Hluw Arabic Arab Armenian Armn Avestan Avst Balinese Bali Bamum Bamu Bassa_Vah Bass Batak Batk Bengali Beng Bhaiksuki Bhks Bopomofo Bopo Brahmi Brah Braille Brai Buginese Bugi Buhid Buhd Canadian_Aboriginal Cans Carian Cari Caucasian_Albanian Aghb Chakma Cakm Cham Cham Cherokee Cher Common Zyyy Coptic Copt Qaac Cuneiform Xsux Cypriot Cprt Cyrillic Cyrl Deseret Dsrt Devanagari Deva Duployan Dupl Egyptian_Hieroglyphs Egyp Elbasan Elba Ethiopic Ethi Georgian Geor Glagolitic Glag Gothic Goth Grantha Gran Greek Grek Gujarati Gujr Gurmukhi Guru Han Hani Hangul Hang Hanunoo Hano Hatran Hatr Hebrew Hebr Hiragana Hira Imperial_Aramaic Armi Inherited Zinh Qaai Inscriptional_Pahlavi Phli Inscriptional_Parthian Prti Javanese Java Kaithi Kthi Kannada Knda Katakana Kana Kayah_Li Kali Kharoshthi Khar Khmer Khmr Khojki Khoj Khudawadi Sind Lao Laoo Latin Latn Lepcha Lepc Limbu Limb Linear_A Lina Linear_B Linb Lisu Lisu Lycian Lyci Lydian Lydi Mahajani Mahj Malayalam Mlym Mandaic Mand Manichaean Mani Marchen Marc Masaram_Gondi Gonm Meetei_Mayek Mtei Mende_Kikakui Mend Meroitic_Cursive Merc Meroitic_Hieroglyphs Mero Miao Plrd Modi Mongolian Mong Mro Mroo Multani Mult Myanmar Mymr Nabataean Nbat New_Tai_Lue Talu Newa Newa Nko Nkoo Nushu Nshu Ogham Ogam Ol_Chiki Olck Old_Hungarian Hung Old_Italic Ital Old_North_Arabian Narb Old_Permic Perm Old_Persian Xpeo Old_South_Arabian Sarb Old_Turkic Orkh Oriya Orya Osage Osge Osmanya Osma Pahawh_Hmong Hmng Palmyrene Palm Pau_Cin_Hau Pauc Phags_Pa Phag Phoenician Phnx Psalter_Pahlavi Phlp Rejang Rjng Runic Runr Samaritan Samr Saurashtra Saur Sharada Shrd Shavian Shaw Siddham Sidd SignWriting Sgnw Sinhala Sinh Sora_Sompeng Sora Soyombo Soyo Sundanese Sund Syloti_Nagri Sylo Syriac Syrc Tagalog Tglg Tagbanwa Tagb Tai_Le Tale Tai_Tham Lana Tai_Viet Tavt Takri Takr Tamil Taml Tangut Tang Telugu Telu Thaana Thaa Thai Thai Tibetan Tibt Tifinagh Tfng Tirhuta Tirh Ugaritic Ugar Vai Vaii Warang_Citi Wara Yi Yiii Zanabazar_Square Zanb"; + var ecma10ScriptValues = ecma9ScriptValues + " Dogra Dogr Gunjala_Gondi Gong Hanifi_Rohingya Rohg Makasar Maka Medefaidrin Medf Old_Sogdian Sogo Sogdian Sogd"; + var ecma11ScriptValues = ecma10ScriptValues + " Elymaic Elym Nandinagari Nand Nyiakeng_Puachue_Hmong Hmnp Wancho Wcho"; + var ecma12ScriptValues = ecma11ScriptValues + " Chorasmian Chrs Diak Dives_Akuru Khitan_Small_Script Kits Yezi Yezidi"; + var ecma13ScriptValues = ecma12ScriptValues + " Cypro_Minoan Cpmn Old_Uyghur Ougr Tangsa Tnsa Toto Vithkuqi Vith"; + var ecma14ScriptValues = ecma13ScriptValues + " " + scriptValuesAddedInUnicode; + + var unicodeScriptValues = { + 9: ecma9ScriptValues, + 10: ecma10ScriptValues, + 11: ecma11ScriptValues, + 12: ecma12ScriptValues, + 13: ecma13ScriptValues, + 14: ecma14ScriptValues + }; + + var data = {}; + function buildUnicodeData(ecmaVersion) { + var d = data[ecmaVersion] = { + binary: wordsRegexp(unicodeBinaryProperties[ecmaVersion] + " " + unicodeGeneralCategoryValues), + binaryOfStrings: wordsRegexp(unicodeBinaryPropertiesOfStrings[ecmaVersion]), + nonBinary: { + General_Category: wordsRegexp(unicodeGeneralCategoryValues), + Script: wordsRegexp(unicodeScriptValues[ecmaVersion]) + } + }; + d.nonBinary.Script_Extensions = d.nonBinary.Script; + + d.nonBinary.gc = d.nonBinary.General_Category; + d.nonBinary.sc = d.nonBinary.Script; + d.nonBinary.scx = d.nonBinary.Script_Extensions; + } + + for (var i = 0, list = [9, 10, 11, 12, 13, 14]; i < list.length; i += 1) { + var ecmaVersion = list[i]; + + buildUnicodeData(ecmaVersion); + } + + var pp$1 = Parser.prototype; + + // Track disjunction structure to determine whether a duplicate + // capture group name is allowed because it is in a separate branch. + var BranchID = function BranchID(parent, base) { + // Parent disjunction branch + this.parent = parent; + // Identifies this set of sibling branches + this.base = base || this; + }; + + BranchID.prototype.separatedFrom = function separatedFrom (alt) { + // A branch is separate from another branch if they or any of + // their parents are siblings in a given disjunction + for (var self = this; self; self = self.parent) { + for (var other = alt; other; other = other.parent) { + if (self.base === other.base && self !== other) { return true } + } + } + return false + }; + + BranchID.prototype.sibling = function sibling () { + return new BranchID(this.parent, this.base) + }; + + var RegExpValidationState = function RegExpValidationState(parser) { + this.parser = parser; + this.validFlags = "gim" + (parser.options.ecmaVersion >= 6 ? "uy" : "") + (parser.options.ecmaVersion >= 9 ? "s" : "") + (parser.options.ecmaVersion >= 13 ? "d" : "") + (parser.options.ecmaVersion >= 15 ? "v" : ""); + this.unicodeProperties = data[parser.options.ecmaVersion >= 14 ? 14 : parser.options.ecmaVersion]; + this.source = ""; + this.flags = ""; + this.start = 0; + this.switchU = false; + this.switchV = false; + this.switchN = false; + this.pos = 0; + this.lastIntValue = 0; + this.lastStringValue = ""; + this.lastAssertionIsQuantifiable = false; + this.numCapturingParens = 0; + this.maxBackReference = 0; + this.groupNames = Object.create(null); + this.backReferenceNames = []; + this.branchID = null; + }; + + RegExpValidationState.prototype.reset = function reset (start, pattern, flags) { + var unicodeSets = flags.indexOf("v") !== -1; + var unicode = flags.indexOf("u") !== -1; + this.start = start | 0; + this.source = pattern + ""; + this.flags = flags; + if (unicodeSets && this.parser.options.ecmaVersion >= 15) { + this.switchU = true; + this.switchV = true; + this.switchN = true; + } else { + this.switchU = unicode && this.parser.options.ecmaVersion >= 6; + this.switchV = false; + this.switchN = unicode && this.parser.options.ecmaVersion >= 9; + } + }; + + RegExpValidationState.prototype.raise = function raise (message) { + this.parser.raiseRecoverable(this.start, ("Invalid regular expression: /" + (this.source) + "/: " + message)); + }; + + // If u flag is given, this returns the code point at the index (it combines a surrogate pair). + // Otherwise, this returns the code unit of the index (can be a part of a surrogate pair). + RegExpValidationState.prototype.at = function at (i, forceU) { + if ( forceU === void 0 ) forceU = false; + + var s = this.source; + var l = s.length; + if (i >= l) { + return -1 + } + var c = s.charCodeAt(i); + if (!(forceU || this.switchU) || c <= 0xD7FF || c >= 0xE000 || i + 1 >= l) { + return c + } + var next = s.charCodeAt(i + 1); + return next >= 0xDC00 && next <= 0xDFFF ? (c << 10) + next - 0x35FDC00 : c + }; + + RegExpValidationState.prototype.nextIndex = function nextIndex (i, forceU) { + if ( forceU === void 0 ) forceU = false; + + var s = this.source; + var l = s.length; + if (i >= l) { + return l + } + var c = s.charCodeAt(i), next; + if (!(forceU || this.switchU) || c <= 0xD7FF || c >= 0xE000 || i + 1 >= l || + (next = s.charCodeAt(i + 1)) < 0xDC00 || next > 0xDFFF) { + return i + 1 + } + return i + 2 + }; + + RegExpValidationState.prototype.current = function current (forceU) { + if ( forceU === void 0 ) forceU = false; + + return this.at(this.pos, forceU) + }; + + RegExpValidationState.prototype.lookahead = function lookahead (forceU) { + if ( forceU === void 0 ) forceU = false; + + return this.at(this.nextIndex(this.pos, forceU), forceU) + }; + + RegExpValidationState.prototype.advance = function advance (forceU) { + if ( forceU === void 0 ) forceU = false; + + this.pos = this.nextIndex(this.pos, forceU); + }; + + RegExpValidationState.prototype.eat = function eat (ch, forceU) { + if ( forceU === void 0 ) forceU = false; + + if (this.current(forceU) === ch) { + this.advance(forceU); + return true + } + return false + }; + + RegExpValidationState.prototype.eatChars = function eatChars (chs, forceU) { + if ( forceU === void 0 ) forceU = false; + + var pos = this.pos; + for (var i = 0, list = chs; i < list.length; i += 1) { + var ch = list[i]; + + var current = this.at(pos, forceU); + if (current === -1 || current !== ch) { + return false + } + pos = this.nextIndex(pos, forceU); + } + this.pos = pos; + return true + }; + + /** + * Validate the flags part of a given RegExpLiteral. + * + * @param {RegExpValidationState} state The state to validate RegExp. + * @returns {void} + */ + pp$1.validateRegExpFlags = function(state) { + var validFlags = state.validFlags; + var flags = state.flags; + + var u = false; + var v = false; + + for (var i = 0; i < flags.length; i++) { + var flag = flags.charAt(i); + if (validFlags.indexOf(flag) === -1) { + this.raise(state.start, "Invalid regular expression flag"); + } + if (flags.indexOf(flag, i + 1) > -1) { + this.raise(state.start, "Duplicate regular expression flag"); + } + if (flag === "u") { u = true; } + if (flag === "v") { v = true; } + } + if (this.options.ecmaVersion >= 15 && u && v) { + this.raise(state.start, "Invalid regular expression flag"); + } + }; + + function hasProp(obj) { + for (var _ in obj) { return true } + return false + } + + /** + * Validate the pattern part of a given RegExpLiteral. + * + * @param {RegExpValidationState} state The state to validate RegExp. + * @returns {void} + */ + pp$1.validateRegExpPattern = function(state) { + this.regexp_pattern(state); + + // The goal symbol for the parse is |Pattern[~U, ~N]|. If the result of + // parsing contains a |GroupName|, reparse with the goal symbol + // |Pattern[~U, +N]| and use this result instead. Throw a *SyntaxError* + // exception if _P_ did not conform to the grammar, if any elements of _P_ + // were not matched by the parse, or if any Early Error conditions exist. + if (!state.switchN && this.options.ecmaVersion >= 9 && hasProp(state.groupNames)) { + state.switchN = true; + this.regexp_pattern(state); + } + }; + + // https://www.ecma-international.org/ecma-262/8.0/#prod-Pattern + pp$1.regexp_pattern = function(state) { + state.pos = 0; + state.lastIntValue = 0; + state.lastStringValue = ""; + state.lastAssertionIsQuantifiable = false; + state.numCapturingParens = 0; + state.maxBackReference = 0; + state.groupNames = Object.create(null); + state.backReferenceNames.length = 0; + state.branchID = null; + + this.regexp_disjunction(state); + + if (state.pos !== state.source.length) { + // Make the same messages as V8. + if (state.eat(0x29 /* ) */)) { + state.raise("Unmatched ')'"); + } + if (state.eat(0x5D /* ] */) || state.eat(0x7D /* } */)) { + state.raise("Lone quantifier brackets"); + } + } + if (state.maxBackReference > state.numCapturingParens) { + state.raise("Invalid escape"); + } + for (var i = 0, list = state.backReferenceNames; i < list.length; i += 1) { + var name = list[i]; + + if (!state.groupNames[name]) { + state.raise("Invalid named capture referenced"); + } + } + }; + + // https://www.ecma-international.org/ecma-262/8.0/#prod-Disjunction + pp$1.regexp_disjunction = function(state) { + var trackDisjunction = this.options.ecmaVersion >= 16; + if (trackDisjunction) { state.branchID = new BranchID(state.branchID, null); } + this.regexp_alternative(state); + while (state.eat(0x7C /* | */)) { + if (trackDisjunction) { state.branchID = state.branchID.sibling(); } + this.regexp_alternative(state); + } + if (trackDisjunction) { state.branchID = state.branchID.parent; } + + // Make the same message as V8. + if (this.regexp_eatQuantifier(state, true)) { + state.raise("Nothing to repeat"); + } + if (state.eat(0x7B /* { */)) { + state.raise("Lone quantifier brackets"); + } + }; + + // https://www.ecma-international.org/ecma-262/8.0/#prod-Alternative + pp$1.regexp_alternative = function(state) { + while (state.pos < state.source.length && this.regexp_eatTerm(state)) {} + }; + + // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-Term + pp$1.regexp_eatTerm = function(state) { + if (this.regexp_eatAssertion(state)) { + // Handle `QuantifiableAssertion Quantifier` alternative. + // `state.lastAssertionIsQuantifiable` is true if the last eaten Assertion + // is a QuantifiableAssertion. + if (state.lastAssertionIsQuantifiable && this.regexp_eatQuantifier(state)) { + // Make the same message as V8. + if (state.switchU) { + state.raise("Invalid quantifier"); + } + } + return true + } + + if (state.switchU ? this.regexp_eatAtom(state) : this.regexp_eatExtendedAtom(state)) { + this.regexp_eatQuantifier(state); + return true + } + + return false + }; + + // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-Assertion + pp$1.regexp_eatAssertion = function(state) { + var start = state.pos; + state.lastAssertionIsQuantifiable = false; + + // ^, $ + if (state.eat(0x5E /* ^ */) || state.eat(0x24 /* $ */)) { + return true + } + + // \b \B + if (state.eat(0x5C /* \ */)) { + if (state.eat(0x42 /* B */) || state.eat(0x62 /* b */)) { + return true + } + state.pos = start; + } + + // Lookahead / Lookbehind + if (state.eat(0x28 /* ( */) && state.eat(0x3F /* ? */)) { + var lookbehind = false; + if (this.options.ecmaVersion >= 9) { + lookbehind = state.eat(0x3C /* < */); + } + if (state.eat(0x3D /* = */) || state.eat(0x21 /* ! */)) { + this.regexp_disjunction(state); + if (!state.eat(0x29 /* ) */)) { + state.raise("Unterminated group"); + } + state.lastAssertionIsQuantifiable = !lookbehind; + return true + } + } + + state.pos = start; + return false + }; + + // https://www.ecma-international.org/ecma-262/8.0/#prod-Quantifier + pp$1.regexp_eatQuantifier = function(state, noError) { + if ( noError === void 0 ) noError = false; + + if (this.regexp_eatQuantifierPrefix(state, noError)) { + state.eat(0x3F /* ? */); + return true + } + return false + }; + + // https://www.ecma-international.org/ecma-262/8.0/#prod-QuantifierPrefix + pp$1.regexp_eatQuantifierPrefix = function(state, noError) { + return ( + state.eat(0x2A /* * */) || + state.eat(0x2B /* + */) || + state.eat(0x3F /* ? */) || + this.regexp_eatBracedQuantifier(state, noError) + ) + }; + pp$1.regexp_eatBracedQuantifier = function(state, noError) { + var start = state.pos; + if (state.eat(0x7B /* { */)) { + var min = 0, max = -1; + if (this.regexp_eatDecimalDigits(state)) { + min = state.lastIntValue; + if (state.eat(0x2C /* , */) && this.regexp_eatDecimalDigits(state)) { + max = state.lastIntValue; + } + if (state.eat(0x7D /* } */)) { + // SyntaxError in https://www.ecma-international.org/ecma-262/8.0/#sec-term + if (max !== -1 && max < min && !noError) { + state.raise("numbers out of order in {} quantifier"); + } + return true + } + } + if (state.switchU && !noError) { + state.raise("Incomplete quantifier"); + } + state.pos = start; + } + return false + }; + + // https://www.ecma-international.org/ecma-262/8.0/#prod-Atom + pp$1.regexp_eatAtom = function(state) { + return ( + this.regexp_eatPatternCharacters(state) || + state.eat(0x2E /* . */) || + this.regexp_eatReverseSolidusAtomEscape(state) || + this.regexp_eatCharacterClass(state) || + this.regexp_eatUncapturingGroup(state) || + this.regexp_eatCapturingGroup(state) + ) + }; + pp$1.regexp_eatReverseSolidusAtomEscape = function(state) { + var start = state.pos; + if (state.eat(0x5C /* \ */)) { + if (this.regexp_eatAtomEscape(state)) { + return true + } + state.pos = start; + } + return false + }; + pp$1.regexp_eatUncapturingGroup = function(state) { + var start = state.pos; + if (state.eat(0x28 /* ( */)) { + if (state.eat(0x3F /* ? */)) { + if (this.options.ecmaVersion >= 16) { + var addModifiers = this.regexp_eatModifiers(state); + var hasHyphen = state.eat(0x2D /* - */); + if (addModifiers || hasHyphen) { + for (var i = 0; i < addModifiers.length; i++) { + var modifier = addModifiers.charAt(i); + if (addModifiers.indexOf(modifier, i + 1) > -1) { + state.raise("Duplicate regular expression modifiers"); + } + } + if (hasHyphen) { + var removeModifiers = this.regexp_eatModifiers(state); + if (!addModifiers && !removeModifiers && state.current() === 0x3A /* : */) { + state.raise("Invalid regular expression modifiers"); + } + for (var i$1 = 0; i$1 < removeModifiers.length; i$1++) { + var modifier$1 = removeModifiers.charAt(i$1); + if ( + removeModifiers.indexOf(modifier$1, i$1 + 1) > -1 || + addModifiers.indexOf(modifier$1) > -1 + ) { + state.raise("Duplicate regular expression modifiers"); + } + } + } + } + } + if (state.eat(0x3A /* : */)) { + this.regexp_disjunction(state); + if (state.eat(0x29 /* ) */)) { + return true + } + state.raise("Unterminated group"); + } + } + state.pos = start; + } + return false + }; + pp$1.regexp_eatCapturingGroup = function(state) { + if (state.eat(0x28 /* ( */)) { + if (this.options.ecmaVersion >= 9) { + this.regexp_groupSpecifier(state); + } else if (state.current() === 0x3F /* ? */) { + state.raise("Invalid group"); + } + this.regexp_disjunction(state); + if (state.eat(0x29 /* ) */)) { + state.numCapturingParens += 1; + return true + } + state.raise("Unterminated group"); + } + return false + }; + // RegularExpressionModifiers :: + // [empty] + // RegularExpressionModifiers RegularExpressionModifier + pp$1.regexp_eatModifiers = function(state) { + var modifiers = ""; + var ch = 0; + while ((ch = state.current()) !== -1 && isRegularExpressionModifier(ch)) { + modifiers += codePointToString(ch); + state.advance(); + } + return modifiers + }; + // RegularExpressionModifier :: one of + // `i` `m` `s` + function isRegularExpressionModifier(ch) { + return ch === 0x69 /* i */ || ch === 0x6d /* m */ || ch === 0x73 /* s */ + } + + // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ExtendedAtom + pp$1.regexp_eatExtendedAtom = function(state) { + return ( + state.eat(0x2E /* . */) || + this.regexp_eatReverseSolidusAtomEscape(state) || + this.regexp_eatCharacterClass(state) || + this.regexp_eatUncapturingGroup(state) || + this.regexp_eatCapturingGroup(state) || + this.regexp_eatInvalidBracedQuantifier(state) || + this.regexp_eatExtendedPatternCharacter(state) + ) + }; + + // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-InvalidBracedQuantifier + pp$1.regexp_eatInvalidBracedQuantifier = function(state) { + if (this.regexp_eatBracedQuantifier(state, true)) { + state.raise("Nothing to repeat"); + } + return false + }; + + // https://www.ecma-international.org/ecma-262/8.0/#prod-SyntaxCharacter + pp$1.regexp_eatSyntaxCharacter = function(state) { + var ch = state.current(); + if (isSyntaxCharacter(ch)) { + state.lastIntValue = ch; + state.advance(); + return true + } + return false + }; + function isSyntaxCharacter(ch) { + return ( + ch === 0x24 /* $ */ || + ch >= 0x28 /* ( */ && ch <= 0x2B /* + */ || + ch === 0x2E /* . */ || + ch === 0x3F /* ? */ || + ch >= 0x5B /* [ */ && ch <= 0x5E /* ^ */ || + ch >= 0x7B /* { */ && ch <= 0x7D /* } */ + ) + } + + // https://www.ecma-international.org/ecma-262/8.0/#prod-PatternCharacter + // But eat eager. + pp$1.regexp_eatPatternCharacters = function(state) { + var start = state.pos; + var ch = 0; + while ((ch = state.current()) !== -1 && !isSyntaxCharacter(ch)) { + state.advance(); + } + return state.pos !== start + }; + + // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ExtendedPatternCharacter + pp$1.regexp_eatExtendedPatternCharacter = function(state) { + var ch = state.current(); + if ( + ch !== -1 && + ch !== 0x24 /* $ */ && + !(ch >= 0x28 /* ( */ && ch <= 0x2B /* + */) && + ch !== 0x2E /* . */ && + ch !== 0x3F /* ? */ && + ch !== 0x5B /* [ */ && + ch !== 0x5E /* ^ */ && + ch !== 0x7C /* | */ + ) { + state.advance(); + return true + } + return false + }; + + // GroupSpecifier :: + // [empty] + // `?` GroupName + pp$1.regexp_groupSpecifier = function(state) { + if (state.eat(0x3F /* ? */)) { + if (!this.regexp_eatGroupName(state)) { state.raise("Invalid group"); } + var trackDisjunction = this.options.ecmaVersion >= 16; + var known = state.groupNames[state.lastStringValue]; + if (known) { + if (trackDisjunction) { + for (var i = 0, list = known; i < list.length; i += 1) { + var altID = list[i]; + + if (!altID.separatedFrom(state.branchID)) + { state.raise("Duplicate capture group name"); } + } + } else { + state.raise("Duplicate capture group name"); + } + } + if (trackDisjunction) { + (known || (state.groupNames[state.lastStringValue] = [])).push(state.branchID); + } else { + state.groupNames[state.lastStringValue] = true; + } + } + }; + + // GroupName :: + // `<` RegExpIdentifierName `>` + // Note: this updates `state.lastStringValue` property with the eaten name. + pp$1.regexp_eatGroupName = function(state) { + state.lastStringValue = ""; + if (state.eat(0x3C /* < */)) { + if (this.regexp_eatRegExpIdentifierName(state) && state.eat(0x3E /* > */)) { + return true + } + state.raise("Invalid capture group name"); + } + return false + }; + + // RegExpIdentifierName :: + // RegExpIdentifierStart + // RegExpIdentifierName RegExpIdentifierPart + // Note: this updates `state.lastStringValue` property with the eaten name. + pp$1.regexp_eatRegExpIdentifierName = function(state) { + state.lastStringValue = ""; + if (this.regexp_eatRegExpIdentifierStart(state)) { + state.lastStringValue += codePointToString(state.lastIntValue); + while (this.regexp_eatRegExpIdentifierPart(state)) { + state.lastStringValue += codePointToString(state.lastIntValue); + } + return true + } + return false + }; + + // RegExpIdentifierStart :: + // UnicodeIDStart + // `$` + // `_` + // `\` RegExpUnicodeEscapeSequence[+U] + pp$1.regexp_eatRegExpIdentifierStart = function(state) { + var start = state.pos; + var forceU = this.options.ecmaVersion >= 11; + var ch = state.current(forceU); + state.advance(forceU); + + if (ch === 0x5C /* \ */ && this.regexp_eatRegExpUnicodeEscapeSequence(state, forceU)) { + ch = state.lastIntValue; + } + if (isRegExpIdentifierStart(ch)) { + state.lastIntValue = ch; + return true + } + + state.pos = start; + return false + }; + function isRegExpIdentifierStart(ch) { + return isIdentifierStart(ch, true) || ch === 0x24 /* $ */ || ch === 0x5F /* _ */ + } + + // RegExpIdentifierPart :: + // UnicodeIDContinue + // `$` + // `_` + // `\` RegExpUnicodeEscapeSequence[+U] + // + // + pp$1.regexp_eatRegExpIdentifierPart = function(state) { + var start = state.pos; + var forceU = this.options.ecmaVersion >= 11; + var ch = state.current(forceU); + state.advance(forceU); + + if (ch === 0x5C /* \ */ && this.regexp_eatRegExpUnicodeEscapeSequence(state, forceU)) { + ch = state.lastIntValue; + } + if (isRegExpIdentifierPart(ch)) { + state.lastIntValue = ch; + return true + } + + state.pos = start; + return false + }; + function isRegExpIdentifierPart(ch) { + return isIdentifierChar(ch, true) || ch === 0x24 /* $ */ || ch === 0x5F /* _ */ || ch === 0x200C /* */ || ch === 0x200D /* */ + } + + // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-AtomEscape + pp$1.regexp_eatAtomEscape = function(state) { + if ( + this.regexp_eatBackReference(state) || + this.regexp_eatCharacterClassEscape(state) || + this.regexp_eatCharacterEscape(state) || + (state.switchN && this.regexp_eatKGroupName(state)) + ) { + return true + } + if (state.switchU) { + // Make the same message as V8. + if (state.current() === 0x63 /* c */) { + state.raise("Invalid unicode escape"); + } + state.raise("Invalid escape"); + } + return false + }; + pp$1.regexp_eatBackReference = function(state) { + var start = state.pos; + if (this.regexp_eatDecimalEscape(state)) { + var n = state.lastIntValue; + if (state.switchU) { + // For SyntaxError in https://www.ecma-international.org/ecma-262/8.0/#sec-atomescape + if (n > state.maxBackReference) { + state.maxBackReference = n; + } + return true + } + if (n <= state.numCapturingParens) { + return true + } + state.pos = start; + } + return false + }; + pp$1.regexp_eatKGroupName = function(state) { + if (state.eat(0x6B /* k */)) { + if (this.regexp_eatGroupName(state)) { + state.backReferenceNames.push(state.lastStringValue); + return true + } + state.raise("Invalid named reference"); + } + return false + }; + + // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-CharacterEscape + pp$1.regexp_eatCharacterEscape = function(state) { + return ( + this.regexp_eatControlEscape(state) || + this.regexp_eatCControlLetter(state) || + this.regexp_eatZero(state) || + this.regexp_eatHexEscapeSequence(state) || + this.regexp_eatRegExpUnicodeEscapeSequence(state, false) || + (!state.switchU && this.regexp_eatLegacyOctalEscapeSequence(state)) || + this.regexp_eatIdentityEscape(state) + ) + }; + pp$1.regexp_eatCControlLetter = function(state) { + var start = state.pos; + if (state.eat(0x63 /* c */)) { + if (this.regexp_eatControlLetter(state)) { + return true + } + state.pos = start; + } + return false + }; + pp$1.regexp_eatZero = function(state) { + if (state.current() === 0x30 /* 0 */ && !isDecimalDigit(state.lookahead())) { + state.lastIntValue = 0; + state.advance(); + return true + } + return false + }; + + // https://www.ecma-international.org/ecma-262/8.0/#prod-ControlEscape + pp$1.regexp_eatControlEscape = function(state) { + var ch = state.current(); + if (ch === 0x74 /* t */) { + state.lastIntValue = 0x09; /* \t */ + state.advance(); + return true + } + if (ch === 0x6E /* n */) { + state.lastIntValue = 0x0A; /* \n */ + state.advance(); + return true + } + if (ch === 0x76 /* v */) { + state.lastIntValue = 0x0B; /* \v */ + state.advance(); + return true + } + if (ch === 0x66 /* f */) { + state.lastIntValue = 0x0C; /* \f */ + state.advance(); + return true + } + if (ch === 0x72 /* r */) { + state.lastIntValue = 0x0D; /* \r */ + state.advance(); + return true + } + return false + }; + + // https://www.ecma-international.org/ecma-262/8.0/#prod-ControlLetter + pp$1.regexp_eatControlLetter = function(state) { + var ch = state.current(); + if (isControlLetter(ch)) { + state.lastIntValue = ch % 0x20; + state.advance(); + return true + } + return false + }; + function isControlLetter(ch) { + return ( + (ch >= 0x41 /* A */ && ch <= 0x5A /* Z */) || + (ch >= 0x61 /* a */ && ch <= 0x7A /* z */) + ) + } + + // https://www.ecma-international.org/ecma-262/8.0/#prod-RegExpUnicodeEscapeSequence + pp$1.regexp_eatRegExpUnicodeEscapeSequence = function(state, forceU) { + if ( forceU === void 0 ) forceU = false; + + var start = state.pos; + var switchU = forceU || state.switchU; + + if (state.eat(0x75 /* u */)) { + if (this.regexp_eatFixedHexDigits(state, 4)) { + var lead = state.lastIntValue; + if (switchU && lead >= 0xD800 && lead <= 0xDBFF) { + var leadSurrogateEnd = state.pos; + if (state.eat(0x5C /* \ */) && state.eat(0x75 /* u */) && this.regexp_eatFixedHexDigits(state, 4)) { + var trail = state.lastIntValue; + if (trail >= 0xDC00 && trail <= 0xDFFF) { + state.lastIntValue = (lead - 0xD800) * 0x400 + (trail - 0xDC00) + 0x10000; + return true + } + } + state.pos = leadSurrogateEnd; + state.lastIntValue = lead; + } + return true + } + if ( + switchU && + state.eat(0x7B /* { */) && + this.regexp_eatHexDigits(state) && + state.eat(0x7D /* } */) && + isValidUnicode(state.lastIntValue) + ) { + return true + } + if (switchU) { + state.raise("Invalid unicode escape"); + } + state.pos = start; + } + + return false + }; + function isValidUnicode(ch) { + return ch >= 0 && ch <= 0x10FFFF + } + + // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-IdentityEscape + pp$1.regexp_eatIdentityEscape = function(state) { + if (state.switchU) { + if (this.regexp_eatSyntaxCharacter(state)) { + return true + } + if (state.eat(0x2F /* / */)) { + state.lastIntValue = 0x2F; /* / */ + return true + } + return false + } + + var ch = state.current(); + if (ch !== 0x63 /* c */ && (!state.switchN || ch !== 0x6B /* k */)) { + state.lastIntValue = ch; + state.advance(); + return true + } + + return false + }; + + // https://www.ecma-international.org/ecma-262/8.0/#prod-DecimalEscape + pp$1.regexp_eatDecimalEscape = function(state) { + state.lastIntValue = 0; + var ch = state.current(); + if (ch >= 0x31 /* 1 */ && ch <= 0x39 /* 9 */) { + do { + state.lastIntValue = 10 * state.lastIntValue + (ch - 0x30 /* 0 */); + state.advance(); + } while ((ch = state.current()) >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */) + return true + } + return false + }; + + // Return values used by character set parsing methods, needed to + // forbid negation of sets that can match strings. + var CharSetNone = 0; // Nothing parsed + var CharSetOk = 1; // Construct parsed, cannot contain strings + var CharSetString = 2; // Construct parsed, can contain strings + + // https://www.ecma-international.org/ecma-262/8.0/#prod-CharacterClassEscape + pp$1.regexp_eatCharacterClassEscape = function(state) { + var ch = state.current(); + + if (isCharacterClassEscape(ch)) { + state.lastIntValue = -1; + state.advance(); + return CharSetOk + } + + var negate = false; + if ( + state.switchU && + this.options.ecmaVersion >= 9 && + ((negate = ch === 0x50 /* P */) || ch === 0x70 /* p */) + ) { + state.lastIntValue = -1; + state.advance(); + var result; + if ( + state.eat(0x7B /* { */) && + (result = this.regexp_eatUnicodePropertyValueExpression(state)) && + state.eat(0x7D /* } */) + ) { + if (negate && result === CharSetString) { state.raise("Invalid property name"); } + return result + } + state.raise("Invalid property name"); + } + + return CharSetNone + }; + + function isCharacterClassEscape(ch) { + return ( + ch === 0x64 /* d */ || + ch === 0x44 /* D */ || + ch === 0x73 /* s */ || + ch === 0x53 /* S */ || + ch === 0x77 /* w */ || + ch === 0x57 /* W */ + ) + } + + // UnicodePropertyValueExpression :: + // UnicodePropertyName `=` UnicodePropertyValue + // LoneUnicodePropertyNameOrValue + pp$1.regexp_eatUnicodePropertyValueExpression = function(state) { + var start = state.pos; + + // UnicodePropertyName `=` UnicodePropertyValue + if (this.regexp_eatUnicodePropertyName(state) && state.eat(0x3D /* = */)) { + var name = state.lastStringValue; + if (this.regexp_eatUnicodePropertyValue(state)) { + var value = state.lastStringValue; + this.regexp_validateUnicodePropertyNameAndValue(state, name, value); + return CharSetOk + } + } + state.pos = start; + + // LoneUnicodePropertyNameOrValue + if (this.regexp_eatLoneUnicodePropertyNameOrValue(state)) { + var nameOrValue = state.lastStringValue; + return this.regexp_validateUnicodePropertyNameOrValue(state, nameOrValue) + } + return CharSetNone + }; + + pp$1.regexp_validateUnicodePropertyNameAndValue = function(state, name, value) { + if (!hasOwn(state.unicodeProperties.nonBinary, name)) + { state.raise("Invalid property name"); } + if (!state.unicodeProperties.nonBinary[name].test(value)) + { state.raise("Invalid property value"); } + }; + + pp$1.regexp_validateUnicodePropertyNameOrValue = function(state, nameOrValue) { + if (state.unicodeProperties.binary.test(nameOrValue)) { return CharSetOk } + if (state.switchV && state.unicodeProperties.binaryOfStrings.test(nameOrValue)) { return CharSetString } + state.raise("Invalid property name"); + }; + + // UnicodePropertyName :: + // UnicodePropertyNameCharacters + pp$1.regexp_eatUnicodePropertyName = function(state) { + var ch = 0; + state.lastStringValue = ""; + while (isUnicodePropertyNameCharacter(ch = state.current())) { + state.lastStringValue += codePointToString(ch); + state.advance(); + } + return state.lastStringValue !== "" + }; + + function isUnicodePropertyNameCharacter(ch) { + return isControlLetter(ch) || ch === 0x5F /* _ */ + } + + // UnicodePropertyValue :: + // UnicodePropertyValueCharacters + pp$1.regexp_eatUnicodePropertyValue = function(state) { + var ch = 0; + state.lastStringValue = ""; + while (isUnicodePropertyValueCharacter(ch = state.current())) { + state.lastStringValue += codePointToString(ch); + state.advance(); + } + return state.lastStringValue !== "" + }; + function isUnicodePropertyValueCharacter(ch) { + return isUnicodePropertyNameCharacter(ch) || isDecimalDigit(ch) + } + + // LoneUnicodePropertyNameOrValue :: + // UnicodePropertyValueCharacters + pp$1.regexp_eatLoneUnicodePropertyNameOrValue = function(state) { + return this.regexp_eatUnicodePropertyValue(state) + }; + + // https://www.ecma-international.org/ecma-262/8.0/#prod-CharacterClass + pp$1.regexp_eatCharacterClass = function(state) { + if (state.eat(0x5B /* [ */)) { + var negate = state.eat(0x5E /* ^ */); + var result = this.regexp_classContents(state); + if (!state.eat(0x5D /* ] */)) + { state.raise("Unterminated character class"); } + if (negate && result === CharSetString) + { state.raise("Negated character class may contain strings"); } + return true + } + return false + }; + + // https://tc39.es/ecma262/#prod-ClassContents + // https://www.ecma-international.org/ecma-262/8.0/#prod-ClassRanges + pp$1.regexp_classContents = function(state) { + if (state.current() === 0x5D /* ] */) { return CharSetOk } + if (state.switchV) { return this.regexp_classSetExpression(state) } + this.regexp_nonEmptyClassRanges(state); + return CharSetOk + }; + + // https://www.ecma-international.org/ecma-262/8.0/#prod-NonemptyClassRanges + // https://www.ecma-international.org/ecma-262/8.0/#prod-NonemptyClassRangesNoDash + pp$1.regexp_nonEmptyClassRanges = function(state) { + while (this.regexp_eatClassAtom(state)) { + var left = state.lastIntValue; + if (state.eat(0x2D /* - */) && this.regexp_eatClassAtom(state)) { + var right = state.lastIntValue; + if (state.switchU && (left === -1 || right === -1)) { + state.raise("Invalid character class"); + } + if (left !== -1 && right !== -1 && left > right) { + state.raise("Range out of order in character class"); + } + } + } + }; + + // https://www.ecma-international.org/ecma-262/8.0/#prod-ClassAtom + // https://www.ecma-international.org/ecma-262/8.0/#prod-ClassAtomNoDash + pp$1.regexp_eatClassAtom = function(state) { + var start = state.pos; + + if (state.eat(0x5C /* \ */)) { + if (this.regexp_eatClassEscape(state)) { + return true + } + if (state.switchU) { + // Make the same message as V8. + var ch$1 = state.current(); + if (ch$1 === 0x63 /* c */ || isOctalDigit(ch$1)) { + state.raise("Invalid class escape"); + } + state.raise("Invalid escape"); + } + state.pos = start; + } + + var ch = state.current(); + if (ch !== 0x5D /* ] */) { + state.lastIntValue = ch; + state.advance(); + return true + } + + return false + }; + + // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ClassEscape + pp$1.regexp_eatClassEscape = function(state) { + var start = state.pos; + + if (state.eat(0x62 /* b */)) { + state.lastIntValue = 0x08; /* */ + return true + } + + if (state.switchU && state.eat(0x2D /* - */)) { + state.lastIntValue = 0x2D; /* - */ + return true + } + + if (!state.switchU && state.eat(0x63 /* c */)) { + if (this.regexp_eatClassControlLetter(state)) { + return true + } + state.pos = start; + } + + return ( + this.regexp_eatCharacterClassEscape(state) || + this.regexp_eatCharacterEscape(state) + ) + }; + + // https://tc39.es/ecma262/#prod-ClassSetExpression + // https://tc39.es/ecma262/#prod-ClassUnion + // https://tc39.es/ecma262/#prod-ClassIntersection + // https://tc39.es/ecma262/#prod-ClassSubtraction + pp$1.regexp_classSetExpression = function(state) { + var result = CharSetOk, subResult; + if (this.regexp_eatClassSetRange(state)) ; else if (subResult = this.regexp_eatClassSetOperand(state)) { + if (subResult === CharSetString) { result = CharSetString; } + // https://tc39.es/ecma262/#prod-ClassIntersection + var start = state.pos; + while (state.eatChars([0x26, 0x26] /* && */)) { + if ( + state.current() !== 0x26 /* & */ && + (subResult = this.regexp_eatClassSetOperand(state)) + ) { + if (subResult !== CharSetString) { result = CharSetOk; } + continue + } + state.raise("Invalid character in character class"); + } + if (start !== state.pos) { return result } + // https://tc39.es/ecma262/#prod-ClassSubtraction + while (state.eatChars([0x2D, 0x2D] /* -- */)) { + if (this.regexp_eatClassSetOperand(state)) { continue } + state.raise("Invalid character in character class"); + } + if (start !== state.pos) { return result } + } else { + state.raise("Invalid character in character class"); + } + // https://tc39.es/ecma262/#prod-ClassUnion + for (;;) { + if (this.regexp_eatClassSetRange(state)) { continue } + subResult = this.regexp_eatClassSetOperand(state); + if (!subResult) { return result } + if (subResult === CharSetString) { result = CharSetString; } + } + }; + + // https://tc39.es/ecma262/#prod-ClassSetRange + pp$1.regexp_eatClassSetRange = function(state) { + var start = state.pos; + if (this.regexp_eatClassSetCharacter(state)) { + var left = state.lastIntValue; + if (state.eat(0x2D /* - */) && this.regexp_eatClassSetCharacter(state)) { + var right = state.lastIntValue; + if (left !== -1 && right !== -1 && left > right) { + state.raise("Range out of order in character class"); + } + return true + } + state.pos = start; + } + return false + }; + + // https://tc39.es/ecma262/#prod-ClassSetOperand + pp$1.regexp_eatClassSetOperand = function(state) { + if (this.regexp_eatClassSetCharacter(state)) { return CharSetOk } + return this.regexp_eatClassStringDisjunction(state) || this.regexp_eatNestedClass(state) + }; + + // https://tc39.es/ecma262/#prod-NestedClass + pp$1.regexp_eatNestedClass = function(state) { + var start = state.pos; + if (state.eat(0x5B /* [ */)) { + var negate = state.eat(0x5E /* ^ */); + var result = this.regexp_classContents(state); + if (state.eat(0x5D /* ] */)) { + if (negate && result === CharSetString) { + state.raise("Negated character class may contain strings"); + } + return result + } + state.pos = start; + } + if (state.eat(0x5C /* \ */)) { + var result$1 = this.regexp_eatCharacterClassEscape(state); + if (result$1) { + return result$1 + } + state.pos = start; + } + return null + }; + + // https://tc39.es/ecma262/#prod-ClassStringDisjunction + pp$1.regexp_eatClassStringDisjunction = function(state) { + var start = state.pos; + if (state.eatChars([0x5C, 0x71] /* \q */)) { + if (state.eat(0x7B /* { */)) { + var result = this.regexp_classStringDisjunctionContents(state); + if (state.eat(0x7D /* } */)) { + return result + } + } else { + // Make the same message as V8. + state.raise("Invalid escape"); + } + state.pos = start; + } + return null + }; + + // https://tc39.es/ecma262/#prod-ClassStringDisjunctionContents + pp$1.regexp_classStringDisjunctionContents = function(state) { + var result = this.regexp_classString(state); + while (state.eat(0x7C /* | */)) { + if (this.regexp_classString(state) === CharSetString) { result = CharSetString; } + } + return result + }; + + // https://tc39.es/ecma262/#prod-ClassString + // https://tc39.es/ecma262/#prod-NonEmptyClassString + pp$1.regexp_classString = function(state) { + var count = 0; + while (this.regexp_eatClassSetCharacter(state)) { count++; } + return count === 1 ? CharSetOk : CharSetString + }; + + // https://tc39.es/ecma262/#prod-ClassSetCharacter + pp$1.regexp_eatClassSetCharacter = function(state) { + var start = state.pos; + if (state.eat(0x5C /* \ */)) { + if ( + this.regexp_eatCharacterEscape(state) || + this.regexp_eatClassSetReservedPunctuator(state) + ) { + return true + } + if (state.eat(0x62 /* b */)) { + state.lastIntValue = 0x08; /* */ + return true + } + state.pos = start; + return false + } + var ch = state.current(); + if (ch < 0 || ch === state.lookahead() && isClassSetReservedDoublePunctuatorCharacter(ch)) { return false } + if (isClassSetSyntaxCharacter(ch)) { return false } + state.advance(); + state.lastIntValue = ch; + return true + }; + + // https://tc39.es/ecma262/#prod-ClassSetReservedDoublePunctuator + function isClassSetReservedDoublePunctuatorCharacter(ch) { + return ( + ch === 0x21 /* ! */ || + ch >= 0x23 /* # */ && ch <= 0x26 /* & */ || + ch >= 0x2A /* * */ && ch <= 0x2C /* , */ || + ch === 0x2E /* . */ || + ch >= 0x3A /* : */ && ch <= 0x40 /* @ */ || + ch === 0x5E /* ^ */ || + ch === 0x60 /* ` */ || + ch === 0x7E /* ~ */ + ) + } + + // https://tc39.es/ecma262/#prod-ClassSetSyntaxCharacter + function isClassSetSyntaxCharacter(ch) { + return ( + ch === 0x28 /* ( */ || + ch === 0x29 /* ) */ || + ch === 0x2D /* - */ || + ch === 0x2F /* / */ || + ch >= 0x5B /* [ */ && ch <= 0x5D /* ] */ || + ch >= 0x7B /* { */ && ch <= 0x7D /* } */ + ) + } + + // https://tc39.es/ecma262/#prod-ClassSetReservedPunctuator + pp$1.regexp_eatClassSetReservedPunctuator = function(state) { + var ch = state.current(); + if (isClassSetReservedPunctuator(ch)) { + state.lastIntValue = ch; + state.advance(); + return true + } + return false + }; + + // https://tc39.es/ecma262/#prod-ClassSetReservedPunctuator + function isClassSetReservedPunctuator(ch) { + return ( + ch === 0x21 /* ! */ || + ch === 0x23 /* # */ || + ch === 0x25 /* % */ || + ch === 0x26 /* & */ || + ch === 0x2C /* , */ || + ch === 0x2D /* - */ || + ch >= 0x3A /* : */ && ch <= 0x3E /* > */ || + ch === 0x40 /* @ */ || + ch === 0x60 /* ` */ || + ch === 0x7E /* ~ */ + ) + } + + // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ClassControlLetter + pp$1.regexp_eatClassControlLetter = function(state) { + var ch = state.current(); + if (isDecimalDigit(ch) || ch === 0x5F /* _ */) { + state.lastIntValue = ch % 0x20; + state.advance(); + return true + } + return false + }; + + // https://www.ecma-international.org/ecma-262/8.0/#prod-HexEscapeSequence + pp$1.regexp_eatHexEscapeSequence = function(state) { + var start = state.pos; + if (state.eat(0x78 /* x */)) { + if (this.regexp_eatFixedHexDigits(state, 2)) { + return true + } + if (state.switchU) { + state.raise("Invalid escape"); + } + state.pos = start; + } + return false + }; + + // https://www.ecma-international.org/ecma-262/8.0/#prod-DecimalDigits + pp$1.regexp_eatDecimalDigits = function(state) { + var start = state.pos; + var ch = 0; + state.lastIntValue = 0; + while (isDecimalDigit(ch = state.current())) { + state.lastIntValue = 10 * state.lastIntValue + (ch - 0x30 /* 0 */); + state.advance(); + } + return state.pos !== start + }; + function isDecimalDigit(ch) { + return ch >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */ + } + + // https://www.ecma-international.org/ecma-262/8.0/#prod-HexDigits + pp$1.regexp_eatHexDigits = function(state) { + var start = state.pos; + var ch = 0; + state.lastIntValue = 0; + while (isHexDigit(ch = state.current())) { + state.lastIntValue = 16 * state.lastIntValue + hexToInt(ch); + state.advance(); + } + return state.pos !== start + }; + function isHexDigit(ch) { + return ( + (ch >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */) || + (ch >= 0x41 /* A */ && ch <= 0x46 /* F */) || + (ch >= 0x61 /* a */ && ch <= 0x66 /* f */) + ) + } + function hexToInt(ch) { + if (ch >= 0x41 /* A */ && ch <= 0x46 /* F */) { + return 10 + (ch - 0x41 /* A */) + } + if (ch >= 0x61 /* a */ && ch <= 0x66 /* f */) { + return 10 + (ch - 0x61 /* a */) + } + return ch - 0x30 /* 0 */ + } + + // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-LegacyOctalEscapeSequence + // Allows only 0-377(octal) i.e. 0-255(decimal). + pp$1.regexp_eatLegacyOctalEscapeSequence = function(state) { + if (this.regexp_eatOctalDigit(state)) { + var n1 = state.lastIntValue; + if (this.regexp_eatOctalDigit(state)) { + var n2 = state.lastIntValue; + if (n1 <= 3 && this.regexp_eatOctalDigit(state)) { + state.lastIntValue = n1 * 64 + n2 * 8 + state.lastIntValue; + } else { + state.lastIntValue = n1 * 8 + n2; + } + } else { + state.lastIntValue = n1; + } + return true + } + return false + }; + + // https://www.ecma-international.org/ecma-262/8.0/#prod-OctalDigit + pp$1.regexp_eatOctalDigit = function(state) { + var ch = state.current(); + if (isOctalDigit(ch)) { + state.lastIntValue = ch - 0x30; /* 0 */ + state.advance(); + return true + } + state.lastIntValue = 0; + return false + }; + function isOctalDigit(ch) { + return ch >= 0x30 /* 0 */ && ch <= 0x37 /* 7 */ + } + + // https://www.ecma-international.org/ecma-262/8.0/#prod-Hex4Digits + // https://www.ecma-international.org/ecma-262/8.0/#prod-HexDigit + // And HexDigit HexDigit in https://www.ecma-international.org/ecma-262/8.0/#prod-HexEscapeSequence + pp$1.regexp_eatFixedHexDigits = function(state, length) { + var start = state.pos; + state.lastIntValue = 0; + for (var i = 0; i < length; ++i) { + var ch = state.current(); + if (!isHexDigit(ch)) { + state.pos = start; + return false + } + state.lastIntValue = 16 * state.lastIntValue + hexToInt(ch); + state.advance(); + } + return true + }; + + // Object type used to represent tokens. Note that normally, tokens + // simply exist as properties on the parser object. This is only + // used for the onToken callback and the external tokenizer. + + var Token = function Token(p) { + this.type = p.type; + this.value = p.value; + this.start = p.start; + this.end = p.end; + if (p.options.locations) + { this.loc = new SourceLocation(p, p.startLoc, p.endLoc); } + if (p.options.ranges) + { this.range = [p.start, p.end]; } + }; + + // ## Tokenizer + + var pp = Parser.prototype; + + // Move to the next token + + pp.next = function(ignoreEscapeSequenceInKeyword) { + if (!ignoreEscapeSequenceInKeyword && this.type.keyword && this.containsEsc) + { this.raiseRecoverable(this.start, "Escape sequence in keyword " + this.type.keyword); } + if (this.options.onToken) + { this.options.onToken(new Token(this)); } + + this.lastTokEnd = this.end; + this.lastTokStart = this.start; + this.lastTokEndLoc = this.endLoc; + this.lastTokStartLoc = this.startLoc; + this.nextToken(); + }; + + pp.getToken = function() { + this.next(); + return new Token(this) + }; + + // If we're in an ES6 environment, make parsers iterable + if (typeof Symbol !== "undefined") + { pp[Symbol.iterator] = function() { + var this$1$1 = this; + + return { + next: function () { + var token = this$1$1.getToken(); + return { + done: token.type === types$1.eof, + value: token + } + } + } + }; } + + // Toggle strict mode. Re-reads the next number or string to please + // pedantic tests (`"use strict"; 010;` should fail). + + // Read a single token, updating the parser object's token-related + // properties. + + pp.nextToken = function() { + var curContext = this.curContext(); + if (!curContext || !curContext.preserveSpace) { this.skipSpace(); } + + this.start = this.pos; + if (this.options.locations) { this.startLoc = this.curPosition(); } + if (this.pos >= this.input.length) { return this.finishToken(types$1.eof) } + + if (curContext.override) { return curContext.override(this) } + else { this.readToken(this.fullCharCodeAtPos()); } + }; + + pp.readToken = function(code) { + // Identifier or keyword. '\uXXXX' sequences are allowed in + // identifiers, so '\' also dispatches to that. + if (isIdentifierStart(code, this.options.ecmaVersion >= 6) || code === 92 /* '\' */) + { return this.readWord() } + + return this.getTokenFromCode(code) + }; + + pp.fullCharCodeAtPos = function() { + var code = this.input.charCodeAt(this.pos); + if (code <= 0xd7ff || code >= 0xdc00) { return code } + var next = this.input.charCodeAt(this.pos + 1); + return next <= 0xdbff || next >= 0xe000 ? code : (code << 10) + next - 0x35fdc00 + }; + + pp.skipBlockComment = function() { + var startLoc = this.options.onComment && this.curPosition(); + var start = this.pos, end = this.input.indexOf("*/", this.pos += 2); + if (end === -1) { this.raise(this.pos - 2, "Unterminated comment"); } + this.pos = end + 2; + if (this.options.locations) { + for (var nextBreak = (void 0), pos = start; (nextBreak = nextLineBreak(this.input, pos, this.pos)) > -1;) { + ++this.curLine; + pos = this.lineStart = nextBreak; + } + } + if (this.options.onComment) + { this.options.onComment(true, this.input.slice(start + 2, end), start, this.pos, + startLoc, this.curPosition()); } + }; + + pp.skipLineComment = function(startSkip) { + var start = this.pos; + var startLoc = this.options.onComment && this.curPosition(); + var ch = this.input.charCodeAt(this.pos += startSkip); + while (this.pos < this.input.length && !isNewLine(ch)) { + ch = this.input.charCodeAt(++this.pos); + } + if (this.options.onComment) + { this.options.onComment(false, this.input.slice(start + startSkip, this.pos), start, this.pos, + startLoc, this.curPosition()); } + }; + + // Called at the start of the parse and after every token. Skips + // whitespace and comments, and. + + pp.skipSpace = function() { + loop: while (this.pos < this.input.length) { + var ch = this.input.charCodeAt(this.pos); + switch (ch) { + case 32: case 160: // ' ' + ++this.pos; + break + case 13: + if (this.input.charCodeAt(this.pos + 1) === 10) { + ++this.pos; + } + case 10: case 8232: case 8233: + ++this.pos; + if (this.options.locations) { + ++this.curLine; + this.lineStart = this.pos; + } + break + case 47: // '/' + switch (this.input.charCodeAt(this.pos + 1)) { + case 42: // '*' + this.skipBlockComment(); + break + case 47: + this.skipLineComment(2); + break + default: + break loop + } + break + default: + if (ch > 8 && ch < 14 || ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) { + ++this.pos; + } else { + break loop + } + } + } + }; + + // Called at the end of every token. Sets `end`, `val`, and + // maintains `context` and `exprAllowed`, and skips the space after + // the token, so that the next one's `start` will point at the + // right position. + + pp.finishToken = function(type, val) { + this.end = this.pos; + if (this.options.locations) { this.endLoc = this.curPosition(); } + var prevType = this.type; + this.type = type; + this.value = val; + + this.updateContext(prevType); + }; + + // ### Token reading + + // This is the function that is called to fetch the next token. It + // is somewhat obscure, because it works in character codes rather + // than characters, and because operator parsing has been inlined + // into it. + // + // All in the name of speed. + // + pp.readToken_dot = function() { + var next = this.input.charCodeAt(this.pos + 1); + if (next >= 48 && next <= 57) { return this.readNumber(true) } + var next2 = this.input.charCodeAt(this.pos + 2); + if (this.options.ecmaVersion >= 6 && next === 46 && next2 === 46) { // 46 = dot '.' + this.pos += 3; + return this.finishToken(types$1.ellipsis) + } else { + ++this.pos; + return this.finishToken(types$1.dot) + } + }; + + pp.readToken_slash = function() { // '/' + var next = this.input.charCodeAt(this.pos + 1); + if (this.exprAllowed) { ++this.pos; return this.readRegexp() } + if (next === 61) { return this.finishOp(types$1.assign, 2) } + return this.finishOp(types$1.slash, 1) + }; + + pp.readToken_mult_modulo_exp = function(code) { // '%*' + var next = this.input.charCodeAt(this.pos + 1); + var size = 1; + var tokentype = code === 42 ? types$1.star : types$1.modulo; + + // exponentiation operator ** and **= + if (this.options.ecmaVersion >= 7 && code === 42 && next === 42) { + ++size; + tokentype = types$1.starstar; + next = this.input.charCodeAt(this.pos + 2); + } + + if (next === 61) { return this.finishOp(types$1.assign, size + 1) } + return this.finishOp(tokentype, size) + }; + + pp.readToken_pipe_amp = function(code) { // '|&' + var next = this.input.charCodeAt(this.pos + 1); + if (next === code) { + if (this.options.ecmaVersion >= 12) { + var next2 = this.input.charCodeAt(this.pos + 2); + if (next2 === 61) { return this.finishOp(types$1.assign, 3) } + } + return this.finishOp(code === 124 ? types$1.logicalOR : types$1.logicalAND, 2) + } + if (next === 61) { return this.finishOp(types$1.assign, 2) } + return this.finishOp(code === 124 ? types$1.bitwiseOR : types$1.bitwiseAND, 1) + }; + + pp.readToken_caret = function() { // '^' + var next = this.input.charCodeAt(this.pos + 1); + if (next === 61) { return this.finishOp(types$1.assign, 2) } + return this.finishOp(types$1.bitwiseXOR, 1) + }; + + pp.readToken_plus_min = function(code) { // '+-' + var next = this.input.charCodeAt(this.pos + 1); + if (next === code) { + if (next === 45 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 62 && + (this.lastTokEnd === 0 || lineBreak.test(this.input.slice(this.lastTokEnd, this.pos)))) { + // A `-->` line comment + this.skipLineComment(3); + this.skipSpace(); + return this.nextToken() + } + return this.finishOp(types$1.incDec, 2) + } + if (next === 61) { return this.finishOp(types$1.assign, 2) } + return this.finishOp(types$1.plusMin, 1) + }; + + pp.readToken_lt_gt = function(code) { // '<>' + var next = this.input.charCodeAt(this.pos + 1); + var size = 1; + if (next === code) { + size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2; + if (this.input.charCodeAt(this.pos + size) === 61) { return this.finishOp(types$1.assign, size + 1) } + return this.finishOp(types$1.bitShift, size) + } + if (next === 33 && code === 60 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 45 && + this.input.charCodeAt(this.pos + 3) === 45) { + // `` line comment + this.skipLineComment(3); + this.skipSpace(); + return this.nextToken() + } + return this.finishOp(types$1.incDec, 2) + } + if (next === 61) { return this.finishOp(types$1.assign, 2) } + return this.finishOp(types$1.plusMin, 1) +}; + +pp.readToken_lt_gt = function(code) { // '<>' + var next = this.input.charCodeAt(this.pos + 1); + var size = 1; + if (next === code) { + size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2; + if (this.input.charCodeAt(this.pos + size) === 61) { return this.finishOp(types$1.assign, size + 1) } + return this.finishOp(types$1.bitShift, size) + } + if (next === 33 && code === 60 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 45 && + this.input.charCodeAt(this.pos + 3) === 45) { + // ` SYNC --[event loop tick]--> ASYNC_ACTIVE --[interval tick]-> ASYNC_PASSIVE + ^ | + +---------[insert data]-------+ +*/ + +const STORAGE_MODE_IDLE = 0; +const STORAGE_MODE_SYNC = 1; +const STORAGE_MODE_ASYNC = 2; + +/** + * @callback Provide + * @param {PathLike | PathOrFileDescriptor} path path + * @param {EXPECTED_ANY} options options + * @param {FileSystemCallback} callback callback + * @returns {void} + */ + +class CacheBackend { + /** + * @param {number} duration max cache duration of items + * @param {EXPECTED_FUNCTION | undefined} provider async method + * @param {EXPECTED_FUNCTION | undefined} syncProvider sync method + * @param {BaseFileSystem} providerContext call context for the provider methods + */ + constructor(duration, provider, syncProvider, providerContext) { + this._duration = duration; + this._provider = provider; + this._syncProvider = syncProvider; + this._providerContext = providerContext; + /** @type {Map[]>} */ + this._activeAsyncOperations = new Map(); + /** @type {Map }>} */ + this._data = new Map(); + /** @type {Set[]} */ + this._levels = []; + for (let i = 0; i < 10; i++) this._levels.push(new Set()); + for (let i = 5000; i < duration; i += 500) this._levels.push(new Set()); + this._currentLevel = 0; + this._tickInterval = Math.floor(duration / this._levels.length); + /** @type {STORAGE_MODE_IDLE | STORAGE_MODE_SYNC | STORAGE_MODE_ASYNC} */ + this._mode = STORAGE_MODE_IDLE; + + /** @type {NodeJS.Timeout | undefined} */ + this._timeout = undefined; + /** @type {number | undefined} */ + this._nextDecay = undefined; + + // eslint-disable-next-line no-warning-comments + // @ts-ignore + this.provide = provider ? this.provide.bind(this) : null; + // eslint-disable-next-line no-warning-comments + // @ts-ignore + this.provideSync = syncProvider ? this.provideSync.bind(this) : null; + } + + /** + * @param {PathLike | PathOrFileDescriptor} path path + * @param {EXPECTED_ANY} options options + * @param {FileSystemCallback} callback callback + * @returns {void} + */ + provide(path, options, callback) { + if (typeof options === "function") { + callback = options; + options = undefined; + } + if ( + typeof path !== "string" && + !Buffer.isBuffer(path) && + !(path instanceof URL) && + typeof path !== "number" + ) { + callback(new TypeError("path must be a string, Buffer, URL or number")); + return; + } + const strPath = typeof path !== "string" ? path.toString() : path; + if (options) { + return /** @type {EXPECTED_FUNCTION} */ (this._provider).call( + this._providerContext, + path, + options, + callback, + ); + } + + // When in sync mode we can move to async mode + if (this._mode === STORAGE_MODE_SYNC) { + this._enterAsyncMode(); + } + + // Check in cache + const cacheEntry = this._data.get(strPath); + if (cacheEntry !== undefined) { + if (cacheEntry.err) return nextTick(callback, cacheEntry.err); + return nextTick(callback, null, cacheEntry.result); + } + + // Check if there is already the same operation running + let callbacks = this._activeAsyncOperations.get(strPath); + if (callbacks !== undefined) { + callbacks.push(callback); + return; + } + this._activeAsyncOperations.set(strPath, (callbacks = [callback])); + + // Run the operation + /** @type {EXPECTED_FUNCTION} */ + (this._provider).call( + this._providerContext, + path, + /** + * @param {Error | null} err error + * @param {EXPECTED_ANY=} result result + */ + (err, result) => { + this._activeAsyncOperations.delete(strPath); + this._storeResult(strPath, err, result); + + // Enter async mode if not yet done + this._enterAsyncMode(); + + runCallbacks( + /** @type {FileSystemCallback[]} */ (callbacks), + err, + result, + ); + }, + ); + } + + /** + * @param {PathLike | PathOrFileDescriptor} path path + * @param {EXPECTED_ANY} options options + * @returns {EXPECTED_ANY} result + */ + provideSync(path, options) { + if ( + typeof path !== "string" && + !Buffer.isBuffer(path) && + !(path instanceof URL) && + typeof path !== "number" + ) { + throw new TypeError("path must be a string"); + } + const strPath = typeof path !== "string" ? path.toString() : path; + if (options) { + return /** @type {EXPECTED_FUNCTION} */ (this._syncProvider).call( + this._providerContext, + path, + options, + ); + } + + // In sync mode we may have to decay some cache items + if (this._mode === STORAGE_MODE_SYNC) { + this._runDecays(); + } + + // Check in cache + const cacheEntry = this._data.get(strPath); + if (cacheEntry !== undefined) { + if (cacheEntry.err) throw cacheEntry.err; + return cacheEntry.result; + } + + // Get all active async operations + // This sync operation will also complete them + const callbacks = this._activeAsyncOperations.get(strPath); + this._activeAsyncOperations.delete(strPath); + + // Run the operation + // When in idle mode, we will enter sync mode + let result; + try { + result = /** @type {EXPECTED_FUNCTION} */ (this._syncProvider).call( + this._providerContext, + path, + ); + } catch (err) { + this._storeResult(strPath, /** @type {Error} */ (err), undefined); + this._enterSyncModeWhenIdle(); + if (callbacks) { + runCallbacks(callbacks, /** @type {Error} */ (err), undefined); + } + throw err; + } + this._storeResult(strPath, null, result); + this._enterSyncModeWhenIdle(); + if (callbacks) { + runCallbacks(callbacks, null, result); + } + return result; + } + + /** + * @param {(string | Buffer | URL | number | (string | URL | Buffer | number)[] | Set)=} what what to purge + */ + purge(what) { + if (!what) { + if (this._mode !== STORAGE_MODE_IDLE) { + this._data.clear(); + for (const level of this._levels) { + level.clear(); + } + this._enterIdleMode(); + } + } else if ( + typeof what === "string" || + Buffer.isBuffer(what) || + what instanceof URL || + typeof what === "number" + ) { + const strWhat = typeof what !== "string" ? what.toString() : what; + for (const [key, data] of this._data) { + if (key.startsWith(strWhat)) { + this._data.delete(key); + data.level.delete(key); + } + } + if (this._data.size === 0) { + this._enterIdleMode(); + } + } else { + for (const [key, data] of this._data) { + for (const item of what) { + const strItem = typeof item !== "string" ? item.toString() : item; + if (key.startsWith(strItem)) { + this._data.delete(key); + data.level.delete(key); + break; + } + } + } + if (this._data.size === 0) { + this._enterIdleMode(); + } + } + } + + /** + * @param {(string | Buffer | URL | number | (string | URL | Buffer | number)[] | Set)=} what what to purge + */ + purgeParent(what) { + if (!what) { + this.purge(); + } else if ( + typeof what === "string" || + Buffer.isBuffer(what) || + what instanceof URL || + typeof what === "number" + ) { + const strWhat = typeof what !== "string" ? what.toString() : what; + this.purge(dirname(strWhat)); + } else { + const set = new Set(); + for (const item of what) { + const strItem = typeof item !== "string" ? item.toString() : item; + set.add(dirname(strItem)); + } + this.purge(set); + } + } + + /** + * @param {string} path path + * @param {Error | null} err error + * @param {EXPECTED_ANY} result result + */ + _storeResult(path, err, result) { + if (this._data.has(path)) return; + const level = this._levels[this._currentLevel]; + this._data.set(path, { err, result, level }); + level.add(path); + } + + _decayLevel() { + const nextLevel = (this._currentLevel + 1) % this._levels.length; + const decay = this._levels[nextLevel]; + this._currentLevel = nextLevel; + for (const item of decay) { + this._data.delete(item); + } + decay.clear(); + if (this._data.size === 0) { + this._enterIdleMode(); + } else { + /** @type {number} */ + (this._nextDecay) += this._tickInterval; + } + } + + _runDecays() { + while ( + /** @type {number} */ (this._nextDecay) <= Date.now() && + this._mode !== STORAGE_MODE_IDLE + ) { + this._decayLevel(); + } + } + + _enterAsyncMode() { + let timeout = 0; + switch (this._mode) { + case STORAGE_MODE_ASYNC: + return; + case STORAGE_MODE_IDLE: + this._nextDecay = Date.now() + this._tickInterval; + timeout = this._tickInterval; + break; + case STORAGE_MODE_SYNC: + this._runDecays(); + // _runDecays may change the mode + if ( + /** @type {STORAGE_MODE_IDLE | STORAGE_MODE_SYNC | STORAGE_MODE_ASYNC} */ + (this._mode) === STORAGE_MODE_IDLE + ) { + return; + } + timeout = Math.max( + 0, + /** @type {number} */ (this._nextDecay) - Date.now(), + ); + break; + } + this._mode = STORAGE_MODE_ASYNC; + const ref = setTimeout(() => { + this._mode = STORAGE_MODE_SYNC; + this._runDecays(); + }, timeout); + if (ref.unref) ref.unref(); + this._timeout = ref; + } + + _enterSyncModeWhenIdle() { + if (this._mode === STORAGE_MODE_IDLE) { + this._mode = STORAGE_MODE_SYNC; + this._nextDecay = Date.now() + this._tickInterval; + } + } + + _enterIdleMode() { + this._mode = STORAGE_MODE_IDLE; + this._nextDecay = undefined; + if (this._timeout) clearTimeout(this._timeout); + } +} + +/** + * @template {EXPECTED_FUNCTION} Provider + * @template {EXPECTED_FUNCTION} AsyncProvider + * @template FileSystem + * @param {number} duration duration in ms files are cached + * @param {Provider | undefined} provider provider + * @param {AsyncProvider | undefined} syncProvider sync provider + * @param {BaseFileSystem} providerContext provider context + * @returns {OperationMergerBackend | CacheBackend} backend + */ +const createBackend = (duration, provider, syncProvider, providerContext) => { + if (duration > 0) { + return new CacheBackend(duration, provider, syncProvider, providerContext); + } + return new OperationMergerBackend(provider, syncProvider, providerContext); +}; + +module.exports = class CachedInputFileSystem { + /** + * @param {BaseFileSystem} fileSystem file system + * @param {number} duration duration in ms files are cached + */ + constructor(fileSystem, duration) { + this.fileSystem = fileSystem; + + this._lstatBackend = createBackend( + duration, + this.fileSystem.lstat, + this.fileSystem.lstatSync, + this.fileSystem, + ); + const lstat = this._lstatBackend.provide; + this.lstat = /** @type {FileSystem["lstat"]} */ (lstat); + const lstatSync = this._lstatBackend.provideSync; + this.lstatSync = /** @type {SyncFileSystem["lstatSync"]} */ (lstatSync); + + this._statBackend = createBackend( + duration, + this.fileSystem.stat, + this.fileSystem.statSync, + this.fileSystem, + ); + const stat = this._statBackend.provide; + this.stat = /** @type {FileSystem["stat"]} */ (stat); + const statSync = this._statBackend.provideSync; + this.statSync = /** @type {SyncFileSystem["statSync"]} */ (statSync); + + this._readdirBackend = createBackend( + duration, + this.fileSystem.readdir, + this.fileSystem.readdirSync, + this.fileSystem, + ); + const readdir = this._readdirBackend.provide; + this.readdir = /** @type {FileSystem["readdir"]} */ (readdir); + const readdirSync = this._readdirBackend.provideSync; + this.readdirSync = /** @type {SyncFileSystem["readdirSync"]} */ ( + readdirSync + ); + + this._readFileBackend = createBackend( + duration, + this.fileSystem.readFile, + this.fileSystem.readFileSync, + this.fileSystem, + ); + const readFile = this._readFileBackend.provide; + this.readFile = /** @type {FileSystem["readFile"]} */ (readFile); + const readFileSync = this._readFileBackend.provideSync; + this.readFileSync = /** @type {SyncFileSystem["readFileSync"]} */ ( + readFileSync + ); + + this._readJsonBackend = createBackend( + duration, + // prettier-ignore + this.fileSystem.readJson || + (this.readFile && + ( + /** + * @param {string} path path + * @param {FileSystemCallback} callback callback + */ + (path, callback) => { + this.readFile(path, (err, buffer) => { + if (err) return callback(err); + if (!buffer || buffer.length === 0) + {return callback(new Error("No file content"));} + let data; + try { + data = JSON.parse(buffer.toString("utf8")); + } catch (err_) { + return callback(/** @type {Error} */ (err_)); + } + callback(null, data); + }); + }) + ), + // prettier-ignore + this.fileSystem.readJsonSync || + (this.readFileSync && + ( + /** + * @param {string} path path + * @returns {EXPECTED_ANY} result + */ + (path) => { + const buffer = this.readFileSync(path); + const data = JSON.parse(buffer.toString("utf8")); + return data; + } + )), + this.fileSystem, + ); + const readJson = this._readJsonBackend.provide; + this.readJson = /** @type {FileSystem["readJson"]} */ (readJson); + const readJsonSync = this._readJsonBackend.provideSync; + this.readJsonSync = /** @type {SyncFileSystem["readJsonSync"]} */ ( + readJsonSync + ); + + this._readlinkBackend = createBackend( + duration, + this.fileSystem.readlink, + this.fileSystem.readlinkSync, + this.fileSystem, + ); + const readlink = this._readlinkBackend.provide; + this.readlink = /** @type {FileSystem["readlink"]} */ (readlink); + const readlinkSync = this._readlinkBackend.provideSync; + this.readlinkSync = /** @type {SyncFileSystem["readlinkSync"]} */ ( + readlinkSync + ); + + this._realpathBackend = createBackend( + duration, + this.fileSystem.realpath, + this.fileSystem.realpathSync, + this.fileSystem, + ); + const realpath = this._realpathBackend.provide; + this.realpath = /** @type {FileSystem["realpath"]} */ (realpath); + const realpathSync = this._realpathBackend.provideSync; + this.realpathSync = /** @type {SyncFileSystem["realpathSync"]} */ ( + realpathSync + ); + } + + /** + * @param {(string | Buffer | URL | number | (string | URL | Buffer | number)[] | Set)=} what what to purge + */ + purge(what) { + this._statBackend.purge(what); + this._lstatBackend.purge(what); + this._readdirBackend.purgeParent(what); + this._readFileBackend.purge(what); + this._readlinkBackend.purge(what); + this._readJsonBackend.purge(what); + this._realpathBackend.purge(what); + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/CloneBasenamePlugin.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/CloneBasenamePlugin.js new file mode 100644 index 0000000000000000000000000000000000000000..295adaaad183caeacd797000946585c07b48fdbd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/CloneBasenamePlugin.js @@ -0,0 +1,53 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { basename } = require("./getPaths"); + +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ +/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ + +module.exports = class CloneBasenamePlugin { + /** + * @param {string | ResolveStepHook} source source + * @param {string | ResolveStepHook} target target + */ + constructor(source, target) { + this.source = source; + this.target = target; + } + + /** + * @param {Resolver} resolver the resolver + * @returns {void} + */ + apply(resolver) { + const target = resolver.ensureHook(this.target); + resolver + .getHook(this.source) + .tapAsync("CloneBasenamePlugin", (request, resolveContext, callback) => { + const requestPath = /** @type {string} */ (request.path); + const filename = /** @type {string} */ (basename(requestPath)); + const filePath = resolver.join(requestPath, filename); + /** @type {ResolveRequest} */ + const obj = { + ...request, + path: filePath, + relativePath: + request.relativePath && + resolver.join(request.relativePath, filename), + }; + resolver.doResolve( + target, + obj, + `using path: ${filePath}`, + resolveContext, + callback, + ); + }); + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ConditionalPlugin.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ConditionalPlugin.js new file mode 100644 index 0000000000000000000000000000000000000000..99cc09d47cff81f00165f848e4e75964729d9530 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ConditionalPlugin.js @@ -0,0 +1,59 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ +/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ + +module.exports = class ConditionalPlugin { + /** + * @param {string | ResolveStepHook} source source + * @param {Partial} test compare object + * @param {string | null} message log message + * @param {boolean} allowAlternatives when false, do not continue with the current step when "test" matches + * @param {string | ResolveStepHook} target target + */ + constructor(source, test, message, allowAlternatives, target) { + this.source = source; + this.test = test; + this.message = message; + this.allowAlternatives = allowAlternatives; + this.target = target; + } + + /** + * @param {Resolver} resolver the resolver + * @returns {void} + */ + apply(resolver) { + const target = resolver.ensureHook(this.target); + const { test, message, allowAlternatives } = this; + const keys = /** @type {(keyof ResolveRequest)[]} */ (Object.keys(test)); + resolver + .getHook(this.source) + .tapAsync("ConditionalPlugin", (request, resolveContext, callback) => { + for (const prop of keys) { + if (request[prop] !== test[prop]) return callback(); + } + resolver.doResolve( + target, + request, + message, + resolveContext, + allowAlternatives + ? callback + : (err, result) => { + if (err) return callback(err); + + // Don't allow other alternatives + if (result === undefined) return callback(null, null); + callback(null, result); + }, + ); + }); + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/DescriptionFilePlugin.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/DescriptionFilePlugin.js new file mode 100644 index 0000000000000000000000000000000000000000..c20a0c919bcd8050e77f9414fca84649d817265c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/DescriptionFilePlugin.js @@ -0,0 +1,98 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const DescriptionFileUtils = require("./DescriptionFileUtils"); + +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ +/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ + +module.exports = class DescriptionFilePlugin { + /** + * @param {string | ResolveStepHook} source source + * @param {string[]} filenames filenames + * @param {boolean} pathIsFile pathIsFile + * @param {string | ResolveStepHook} target target + */ + constructor(source, filenames, pathIsFile, target) { + this.source = source; + this.filenames = filenames; + this.pathIsFile = pathIsFile; + this.target = target; + } + + /** + * @param {Resolver} resolver the resolver + * @returns {void} + */ + apply(resolver) { + const target = resolver.ensureHook(this.target); + resolver + .getHook(this.source) + .tapAsync( + "DescriptionFilePlugin", + (request, resolveContext, callback) => { + const { path } = request; + if (!path) return callback(); + const directory = this.pathIsFile + ? DescriptionFileUtils.cdUp(path) + : path; + if (!directory) return callback(); + DescriptionFileUtils.loadDescriptionFile( + resolver, + directory, + this.filenames, + request.descriptionFilePath + ? { + path: request.descriptionFilePath, + content: request.descriptionFileData, + directory: + /** @type {string} */ + (request.descriptionFileRoot), + } + : undefined, + resolveContext, + (err, result) => { + if (err) return callback(err); + if (!result) { + if (resolveContext.log) { + resolveContext.log( + `No description file found in ${directory} or above`, + ); + } + return callback(); + } + const relativePath = `.${path + .slice(result.directory.length) + .replace(/\\/g, "/")}`; + /** @type {ResolveRequest} */ + const obj = { + ...request, + descriptionFilePath: result.path, + descriptionFileData: result.content, + descriptionFileRoot: result.directory, + relativePath, + }; + resolver.doResolve( + target, + obj, + `using description file: ${result.path} (relative path: ${relativePath})`, + resolveContext, + (err, result) => { + if (err) return callback(err); + + // Don't allow other processing + if (result === undefined) return callback(null, null); + callback(null, result); + }, + ); + }, + ); + }, + ); + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/DescriptionFileUtils.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/DescriptionFileUtils.js new file mode 100644 index 0000000000000000000000000000000000000000..f41cce35a0c2ca788f3833adac46938026f17a99 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/DescriptionFileUtils.js @@ -0,0 +1,200 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const forEachBail = require("./forEachBail"); + +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").JsonObject} JsonObject */ +/** @typedef {import("./Resolver").JsonValue} JsonValue */ +/** @typedef {import("./Resolver").ResolveContext} ResolveContext */ +/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ + +/** + * @typedef {object} DescriptionFileInfo + * @property {JsonObject=} content content + * @property {string} path path + * @property {string} directory directory + */ + +/** + * @callback ErrorFirstCallback + * @param {Error|null=} error + * @param {DescriptionFileInfo=} result + */ + +/** + * @typedef {object} Result + * @property {string} path path to description file + * @property {string} directory directory of description file + * @property {JsonObject} content content of description file + */ + +/** + * @param {string} directory directory + * @returns {string|null} parent directory or null + */ +function cdUp(directory) { + if (directory === "/") return null; + const i = directory.lastIndexOf("/"); + const j = directory.lastIndexOf("\\"); + const path = i < 0 ? j : j < 0 ? i : i < j ? j : i; + if (path < 0) return null; + return directory.slice(0, path || 1); +} + +/** + * @param {Resolver} resolver resolver + * @param {string} directory directory + * @param {string[]} filenames filenames + * @param {DescriptionFileInfo|undefined} oldInfo oldInfo + * @param {ResolveContext} resolveContext resolveContext + * @param {ErrorFirstCallback} callback callback + */ +function loadDescriptionFile( + resolver, + directory, + filenames, + oldInfo, + resolveContext, + callback, +) { + (function findDescriptionFile() { + if (oldInfo && oldInfo.directory === directory) { + // We already have info for this directory and can reuse it + return callback(null, oldInfo); + } + forEachBail( + filenames, + /** + * @param {string} filename filename + * @param {(err?: null|Error, result?: null|Result) => void} callback callback + * @returns {void} + */ + (filename, callback) => { + const descriptionFilePath = resolver.join(directory, filename); + + /** + * @param {(null | Error)=} err error + * @param {JsonObject=} resolvedContent content + * @returns {void} + */ + function onJson(err, resolvedContent) { + if (err) { + if (resolveContext.log) { + resolveContext.log( + `${descriptionFilePath} (directory description file): ${err}`, + ); + } else { + err.message = `${descriptionFilePath} (directory description file): ${err}`; + } + return callback(err); + } + callback(null, { + content: /** @type {JsonObject} */ (resolvedContent), + directory, + path: descriptionFilePath, + }); + } + + if (resolver.fileSystem.readJson) { + resolver.fileSystem.readJson(descriptionFilePath, (err, content) => { + if (err) { + if ( + typeof (/** @type {NodeJS.ErrnoException} */ (err).code) !== + "undefined" + ) { + if (resolveContext.missingDependencies) { + resolveContext.missingDependencies.add(descriptionFilePath); + } + return callback(); + } + if (resolveContext.fileDependencies) { + resolveContext.fileDependencies.add(descriptionFilePath); + } + return onJson(err); + } + if (resolveContext.fileDependencies) { + resolveContext.fileDependencies.add(descriptionFilePath); + } + onJson(null, content); + }); + } else { + resolver.fileSystem.readFile(descriptionFilePath, (err, content) => { + if (err) { + if (resolveContext.missingDependencies) { + resolveContext.missingDependencies.add(descriptionFilePath); + } + return callback(); + } + if (resolveContext.fileDependencies) { + resolveContext.fileDependencies.add(descriptionFilePath); + } + + /** @type {JsonObject | undefined} */ + let json; + + if (content) { + try { + json = JSON.parse(content.toString()); + } catch (/** @type {unknown} */ err_) { + return onJson(/** @type {Error} */ (err_)); + } + } else { + return onJson(new Error("No content in file")); + } + + onJson(null, json); + }); + } + }, + /** + * @param {(null | Error)=} err error + * @param {(null | Result)=} result result + * @returns {void} + */ + (err, result) => { + if (err) return callback(err); + if (result) return callback(null, result); + const dir = cdUp(directory); + if (!dir) { + return callback(); + } + directory = dir; + return findDescriptionFile(); + }, + ); + })(); +} + +/** + * @param {JsonObject} content content + * @param {string|string[]} field field + * @returns {JsonValue | undefined} field data + */ +function getField(content, field) { + if (!content) return undefined; + if (Array.isArray(field)) { + /** @type {JsonValue} */ + let current = content; + for (let j = 0; j < field.length; j++) { + if (current === null || typeof current !== "object") { + current = null; + break; + } + current = /** @type {JsonValue} */ ( + /** @type {JsonObject} */ + (current)[field[j]] + ); + } + return current; + } + return content[field]; +} + +module.exports.cdUp = cdUp; +module.exports.getField = getField; +module.exports.loadDescriptionFile = loadDescriptionFile; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/DirectoryExistsPlugin.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/DirectoryExistsPlugin.js new file mode 100644 index 0000000000000000000000000000000000000000..78a463941c8cdcaf53e7603210d9fb446c524cb5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/DirectoryExistsPlugin.js @@ -0,0 +1,68 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ + +module.exports = class DirectoryExistsPlugin { + /** + * @param {string | ResolveStepHook} source source + * @param {string | ResolveStepHook} target target + */ + constructor(source, target) { + this.source = source; + this.target = target; + } + + /** + * @param {Resolver} resolver the resolver + * @returns {void} + */ + apply(resolver) { + const target = resolver.ensureHook(this.target); + resolver + .getHook(this.source) + .tapAsync( + "DirectoryExistsPlugin", + (request, resolveContext, callback) => { + const fs = resolver.fileSystem; + const directory = request.path; + if (!directory) return callback(); + fs.stat(directory, (err, stat) => { + if (err || !stat) { + if (resolveContext.missingDependencies) { + resolveContext.missingDependencies.add(directory); + } + if (resolveContext.log) { + resolveContext.log(`${directory} doesn't exist`); + } + return callback(); + } + if (!stat.isDirectory()) { + if (resolveContext.missingDependencies) { + resolveContext.missingDependencies.add(directory); + } + if (resolveContext.log) { + resolveContext.log(`${directory} is not a directory`); + } + return callback(); + } + if (resolveContext.fileDependencies) { + resolveContext.fileDependencies.add(directory); + } + resolver.doResolve( + target, + request, + `existing directory ${directory}`, + resolveContext, + callback, + ); + }); + }, + ); + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ExportsFieldPlugin.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ExportsFieldPlugin.js new file mode 100644 index 0000000000000000000000000000000000000000..b6730f0fcc652e4e32bc93b2820d0a35d895c459 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ExportsFieldPlugin.js @@ -0,0 +1,201 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Ivan Kopeykin @vankop +*/ + +"use strict"; + +const DescriptionFileUtils = require("./DescriptionFileUtils"); +const forEachBail = require("./forEachBail"); +const { processExportsField } = require("./util/entrypoints"); +const { parseIdentifier } = require("./util/identifier"); +const { + deprecatedInvalidSegmentRegEx, + invalidSegmentRegEx, +} = require("./util/path"); + +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").JsonObject} JsonObject */ +/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ +/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ +/** @typedef {import("./util/entrypoints").ExportsField} ExportsField */ +/** @typedef {import("./util/entrypoints").FieldProcessor} FieldProcessor */ + +module.exports = class ExportsFieldPlugin { + /** + * @param {string | ResolveStepHook} source source + * @param {Set} conditionNames condition names + * @param {string | string[]} fieldNamePath name path + * @param {string | ResolveStepHook} target target + */ + constructor(source, conditionNames, fieldNamePath, target) { + this.source = source; + this.target = target; + this.conditionNames = conditionNames; + this.fieldName = fieldNamePath; + /** @type {WeakMap} */ + this.fieldProcessorCache = new WeakMap(); + } + + /** + * @param {Resolver} resolver the resolver + * @returns {void} + */ + apply(resolver) { + const target = resolver.ensureHook(this.target); + resolver + .getHook(this.source) + .tapAsync("ExportsFieldPlugin", (request, resolveContext, callback) => { + // When there is no description file, abort + if (!request.descriptionFilePath) return callback(); + if ( + // When the description file is inherited from parent, abort + // (There is no description file inside of this package) + request.relativePath !== "." || + request.request === undefined + ) { + return callback(); + } + + const remainingRequest = + request.query || request.fragment + ? (request.request === "." ? "./" : request.request) + + request.query + + request.fragment + : request.request; + const exportsField = + /** @type {ExportsField|null|undefined} */ + ( + DescriptionFileUtils.getField( + /** @type {JsonObject} */ (request.descriptionFileData), + this.fieldName, + ) + ); + if (!exportsField) return callback(); + + if (request.directory) { + return callback( + new Error( + `Resolving to directories is not possible with the exports field (request was ${remainingRequest}/)`, + ), + ); + } + + /** @type {string[]} */ + let paths; + /** @type {string | null} */ + let usedField; + + try { + // We attach the cache to the description file instead of the exportsField value + // because we use a WeakMap and the exportsField could be a string too. + // Description file is always an object when exports field can be accessed. + let fieldProcessor = this.fieldProcessorCache.get( + /** @type {JsonObject} */ (request.descriptionFileData), + ); + if (fieldProcessor === undefined) { + fieldProcessor = processExportsField(exportsField); + this.fieldProcessorCache.set( + /** @type {JsonObject} */ (request.descriptionFileData), + fieldProcessor, + ); + } + [paths, usedField] = fieldProcessor( + remainingRequest, + this.conditionNames, + ); + } catch (/** @type {unknown} */ err) { + if (resolveContext.log) { + resolveContext.log( + `Exports field in ${request.descriptionFilePath} can't be processed: ${err}`, + ); + } + return callback(/** @type {Error} */ (err)); + } + + if (paths.length === 0) { + return callback( + new Error( + `Package path ${remainingRequest} is not exported from package ${request.descriptionFileRoot} (see exports field in ${request.descriptionFilePath})`, + ), + ); + } + + forEachBail( + paths, + /** + * @param {string} path path + * @param {(err?: null|Error, result?: null|ResolveRequest) => void} callback callback + * @param {number} i index + * @returns {void} + */ + (path, callback, i) => { + const parsedIdentifier = parseIdentifier(path); + + if (!parsedIdentifier) return callback(); + + const [relativePath, query, fragment] = parsedIdentifier; + + if (relativePath.length === 0 || !relativePath.startsWith("./")) { + if (paths.length === i) { + return callback( + new Error( + `Invalid "exports" target "${path}" defined for "${usedField}" in the package config ${request.descriptionFilePath}, targets must start with "./"`, + ), + ); + } + + return callback(); + } + + if ( + invalidSegmentRegEx.exec(relativePath.slice(2)) !== null && + deprecatedInvalidSegmentRegEx.test(relativePath.slice(2)) !== null + ) { + if (paths.length === i) { + return callback( + new Error( + `Invalid "exports" target "${path}" defined for "${usedField}" in the package config ${request.descriptionFilePath}, targets must start with "./"`, + ), + ); + } + + return callback(); + } + + /** @type {ResolveRequest} */ + const obj = { + ...request, + request: undefined, + path: resolver.join( + /** @type {string} */ (request.descriptionFileRoot), + relativePath, + ), + relativePath, + query, + fragment, + }; + + resolver.doResolve( + target, + obj, + `using exports field: ${path}`, + resolveContext, + (err, result) => { + if (err) return callback(err); + // Don't allow to continue - https://github.com/webpack/enhanced-resolve/issues/400 + if (result === undefined) return callback(null, null); + callback(null, result); + }, + ); + }, + /** + * @param {(null | Error)=} err error + * @param {(null | ResolveRequest)=} result result + * @returns {void} + */ + (err, result) => callback(err, result || null), + ); + }); + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ExtensionAliasPlugin.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ExtensionAliasPlugin.js new file mode 100644 index 0000000000000000000000000000000000000000..4184eb36ce0759656adfcd06ec132a8246e8a5a8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ExtensionAliasPlugin.js @@ -0,0 +1,100 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Ivan Kopeykin @vankop +*/ + +"use strict"; + +const forEachBail = require("./forEachBail"); + +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ +/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ +/** @typedef {{ alias: string|string[], extension: string }} ExtensionAliasOption */ + +module.exports = class ExtensionAliasPlugin { + /** + * @param {string | ResolveStepHook} source source + * @param {ExtensionAliasOption} options options + * @param {string | ResolveStepHook} target target + */ + constructor(source, options, target) { + this.source = source; + this.options = options; + this.target = target; + } + + /** + * @param {Resolver} resolver the resolver + * @returns {void} + */ + apply(resolver) { + const target = resolver.ensureHook(this.target); + const { extension, alias } = this.options; + resolver + .getHook(this.source) + .tapAsync("ExtensionAliasPlugin", (request, resolveContext, callback) => { + const requestPath = request.request; + if (!requestPath || !requestPath.endsWith(extension)) return callback(); + const isAliasString = typeof alias === "string"; + /** + * @param {string} alias extension alias + * @param {(err?: null | Error, result?: null|ResolveRequest) => void} callback callback + * @param {number=} index index + * @returns {void} + */ + const resolve = (alias, callback, index) => { + const newRequest = `${requestPath.slice( + 0, + -extension.length, + )}${alias}`; + + return resolver.doResolve( + target, + { + ...request, + request: newRequest, + fullySpecified: true, + }, + `aliased from extension alias with mapping '${extension}' to '${alias}'`, + resolveContext, + (err, result) => { + // Throw error if we are on the last alias (for multiple aliases) and it failed, always throw if we are not an array or we have only one alias + if (!isAliasString && index) { + if (index !== this.options.alias.length) { + if (resolveContext.log) { + resolveContext.log( + `Failed to alias from extension alias with mapping '${extension}' to '${alias}' for '${newRequest}': ${err}`, + ); + } + + return callback(null, result); + } + + return callback(err, result); + } + callback(err, result); + }, + ); + }; + /** + * @param {(null | Error)=} err error + * @param {(null | ResolveRequest)=} result result + * @returns {void} + */ + const stoppingCallback = (err, result) => { + if (err) return callback(err); + if (result) return callback(null, result); + // Don't allow other aliasing or raw request + return callback(null, null); + }; + if (isAliasString) { + resolve(alias, stoppingCallback); + } else if (alias.length > 1) { + forEachBail(alias, resolve, stoppingCallback); + } else { + resolve(alias[0], stoppingCallback); + } + }); + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/FileExistsPlugin.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/FileExistsPlugin.js new file mode 100644 index 0000000000000000000000000000000000000000..cf9c8391bfc5536b69971cbf303e2c74b8de2c28 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/FileExistsPlugin.js @@ -0,0 +1,61 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ + +module.exports = class FileExistsPlugin { + /** + * @param {string | ResolveStepHook} source source + * @param {string | ResolveStepHook} target target + */ + constructor(source, target) { + this.source = source; + this.target = target; + } + + /** + * @param {Resolver} resolver the resolver + * @returns {void} + */ + apply(resolver) { + const target = resolver.ensureHook(this.target); + const fs = resolver.fileSystem; + resolver + .getHook(this.source) + .tapAsync("FileExistsPlugin", (request, resolveContext, callback) => { + const file = request.path; + if (!file) return callback(); + fs.stat(file, (err, stat) => { + if (err || !stat) { + if (resolveContext.missingDependencies) { + resolveContext.missingDependencies.add(file); + } + if (resolveContext.log) resolveContext.log(`${file} doesn't exist`); + return callback(); + } + if (!stat.isFile()) { + if (resolveContext.missingDependencies) { + resolveContext.missingDependencies.add(file); + } + if (resolveContext.log) resolveContext.log(`${file} is not a file`); + return callback(); + } + if (resolveContext.fileDependencies) { + resolveContext.fileDependencies.add(file); + } + resolver.doResolve( + target, + request, + `existing file: ${file}`, + resolveContext, + callback, + ); + }); + }); + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ImportsFieldPlugin.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ImportsFieldPlugin.js new file mode 100644 index 0000000000000000000000000000000000000000..1475677dbf8e01b91f721941f159c3e9081a798a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ImportsFieldPlugin.js @@ -0,0 +1,223 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Ivan Kopeykin @vankop +*/ + +"use strict"; + +const DescriptionFileUtils = require("./DescriptionFileUtils"); +const forEachBail = require("./forEachBail"); +const { processImportsField } = require("./util/entrypoints"); +const { parseIdentifier } = require("./util/identifier"); +const { + deprecatedInvalidSegmentRegEx, + invalidSegmentRegEx, +} = require("./util/path"); + +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").JsonObject} JsonObject */ +/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ +/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ +/** @typedef {import("./util/entrypoints").FieldProcessor} FieldProcessor */ +/** @typedef {import("./util/entrypoints").ImportsField} ImportsField */ + +const dotCode = ".".charCodeAt(0); + +module.exports = class ImportsFieldPlugin { + /** + * @param {string | ResolveStepHook} source source + * @param {Set} conditionNames condition names + * @param {string | string[]} fieldNamePath name path + * @param {string | ResolveStepHook} targetFile target file + * @param {string | ResolveStepHook} targetPackage target package + */ + constructor( + source, + conditionNames, + fieldNamePath, + targetFile, + targetPackage, + ) { + this.source = source; + this.targetFile = targetFile; + this.targetPackage = targetPackage; + this.conditionNames = conditionNames; + this.fieldName = fieldNamePath; + /** @type {WeakMap} */ + this.fieldProcessorCache = new WeakMap(); + } + + /** + * @param {Resolver} resolver the resolver + * @returns {void} + */ + apply(resolver) { + const targetFile = resolver.ensureHook(this.targetFile); + const targetPackage = resolver.ensureHook(this.targetPackage); + + resolver + .getHook(this.source) + .tapAsync("ImportsFieldPlugin", (request, resolveContext, callback) => { + // When there is no description file, abort + if (!request.descriptionFilePath || request.request === undefined) { + return callback(); + } + + const remainingRequest = + request.request + request.query + request.fragment; + const importsField = + /** @type {ImportsField|null|undefined} */ + ( + DescriptionFileUtils.getField( + /** @type {JsonObject} */ (request.descriptionFileData), + this.fieldName, + ) + ); + if (!importsField) return callback(); + + if (request.directory) { + return callback( + new Error( + `Resolving to directories is not possible with the imports field (request was ${remainingRequest}/)`, + ), + ); + } + + /** @type {string[]} */ + let paths; + /** @type {string | null} */ + let usedField; + + try { + // We attach the cache to the description file instead of the importsField value + // because we use a WeakMap and the importsField could be a string too. + // Description file is always an object when exports field can be accessed. + let fieldProcessor = this.fieldProcessorCache.get( + /** @type {JsonObject} */ (request.descriptionFileData), + ); + if (fieldProcessor === undefined) { + fieldProcessor = processImportsField(importsField); + this.fieldProcessorCache.set( + /** @type {JsonObject} */ (request.descriptionFileData), + fieldProcessor, + ); + } + [paths, usedField] = fieldProcessor( + remainingRequest, + this.conditionNames, + ); + } catch (/** @type {unknown} */ err) { + if (resolveContext.log) { + resolveContext.log( + `Imports field in ${request.descriptionFilePath} can't be processed: ${err}`, + ); + } + return callback(/** @type {Error} */ (err)); + } + + if (paths.length === 0) { + return callback( + new Error( + `Package import ${remainingRequest} is not imported from package ${request.descriptionFileRoot} (see imports field in ${request.descriptionFilePath})`, + ), + ); + } + + forEachBail( + paths, + /** + * @param {string} path path + * @param {(err?: null|Error, result?: null|ResolveRequest) => void} callback callback + * @param {number} i index + * @returns {void} + */ + (path, callback, i) => { + const parsedIdentifier = parseIdentifier(path); + + if (!parsedIdentifier) return callback(); + + const [path_, query, fragment] = parsedIdentifier; + + switch (path_.charCodeAt(0)) { + // should be relative + case dotCode: { + if ( + invalidSegmentRegEx.exec(path_.slice(2)) !== null && + deprecatedInvalidSegmentRegEx.test(path_.slice(2)) !== null + ) { + if (paths.length === i) { + return callback( + new Error( + `Invalid "imports" target "${path}" defined for "${usedField}" in the package config ${request.descriptionFilePath}, targets must start with "./"`, + ), + ); + } + + return callback(); + } + + /** @type {ResolveRequest} */ + const obj = { + ...request, + request: undefined, + path: resolver.join( + /** @type {string} */ (request.descriptionFileRoot), + path_, + ), + relativePath: path_, + query, + fragment, + }; + + resolver.doResolve( + targetFile, + obj, + `using imports field: ${path}`, + resolveContext, + (err, result) => { + if (err) return callback(err); + // Don't allow to continue - https://github.com/webpack/enhanced-resolve/issues/400 + if (result === undefined) return callback(null, null); + callback(null, result); + }, + ); + break; + } + + // package resolving + default: { + /** @type {ResolveRequest} */ + const obj = { + ...request, + request: path_, + relativePath: path_, + fullySpecified: true, + query, + fragment, + }; + + resolver.doResolve( + targetPackage, + obj, + `using imports field: ${path}`, + resolveContext, + (err, result) => { + if (err) return callback(err); + // Don't allow to continue - https://github.com/webpack/enhanced-resolve/issues/400 + if (result === undefined) return callback(null, null); + callback(null, result); + }, + ); + } + } + }, + /** + * @param {(null|Error)=} err error + * @param {(null|ResolveRequest)=} result result + * @returns {void} + */ + (err, result) => callback(err, result || null), + ); + }); + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/JoinRequestPartPlugin.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/JoinRequestPartPlugin.js new file mode 100644 index 0000000000000000000000000000000000000000..a171b988046e97682bbdb35ba502d44e81959f10 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/JoinRequestPartPlugin.js @@ -0,0 +1,75 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ +/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ + +const namespaceStartCharCode = "@".charCodeAt(0); + +module.exports = class JoinRequestPartPlugin { + /** + * @param {string | ResolveStepHook} source source + * @param {string | ResolveStepHook} target target + */ + constructor(source, target) { + this.source = source; + this.target = target; + } + + /** + * @param {Resolver} resolver the resolver + * @returns {void} + */ + apply(resolver) { + const target = resolver.ensureHook(this.target); + resolver + .getHook(this.source) + .tapAsync( + "JoinRequestPartPlugin", + (request, resolveContext, callback) => { + const req = request.request || ""; + let i = req.indexOf("/", 3); + + if (i >= 0 && req.charCodeAt(2) === namespaceStartCharCode) { + i = req.indexOf("/", i + 1); + } + + /** @type {string} */ + let moduleName; + /** @type {string} */ + let remainingRequest; + /** @type {boolean} */ + let fullySpecified; + if (i < 0) { + moduleName = req; + remainingRequest = "."; + fullySpecified = false; + } else { + moduleName = req.slice(0, i); + remainingRequest = `.${req.slice(i)}`; + fullySpecified = /** @type {boolean} */ (request.fullySpecified); + } + /** @type {ResolveRequest} */ + const obj = { + ...request, + path: resolver.join( + /** @type {string} */ + (request.path), + moduleName, + ), + relativePath: + request.relativePath && + resolver.join(request.relativePath, moduleName), + request: remainingRequest, + fullySpecified, + }; + resolver.doResolve(target, obj, null, resolveContext, callback); + }, + ); + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/JoinRequestPlugin.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/JoinRequestPlugin.js new file mode 100644 index 0000000000000000000000000000000000000000..108958ec9f1b5b9031d38cc84ac4672036a53141 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/JoinRequestPlugin.js @@ -0,0 +1,45 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ +/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ + +module.exports = class JoinRequestPlugin { + /** + * @param {string | ResolveStepHook} source source + * @param {string | ResolveStepHook} target target + */ + constructor(source, target) { + this.source = source; + this.target = target; + } + + /** + * @param {Resolver} resolver the resolver + * @returns {void} + */ + apply(resolver) { + const target = resolver.ensureHook(this.target); + resolver + .getHook(this.source) + .tapAsync("JoinRequestPlugin", (request, resolveContext, callback) => { + const requestPath = /** @type {string} */ (request.path); + const requestRequest = /** @type {string} */ (request.request); + /** @type {ResolveRequest} */ + const obj = { + ...request, + path: resolver.join(requestPath, requestRequest), + relativePath: + request.relativePath && + resolver.join(request.relativePath, requestRequest), + request: undefined, + }; + resolver.doResolve(target, obj, null, resolveContext, callback); + }); + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/LogInfoPlugin.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/LogInfoPlugin.js new file mode 100644 index 0000000000000000000000000000000000000000..5dbb688e08671e5d6252705251e9af85ccde1a60 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/LogInfoPlugin.js @@ -0,0 +1,58 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ + +module.exports = class LogInfoPlugin { + /** + * @param {string | ResolveStepHook} source source + */ + constructor(source) { + this.source = source; + } + + /** + * @param {Resolver} resolver the resolver + * @returns {void} + */ + apply(resolver) { + const { source } = this; + resolver + .getHook(this.source) + .tapAsync("LogInfoPlugin", (request, resolveContext, callback) => { + if (!resolveContext.log) return callback(); + const { log } = resolveContext; + const prefix = `[${source}] `; + if (request.path) { + log(`${prefix}Resolving in directory: ${request.path}`); + } + if (request.request) { + log(`${prefix}Resolving request: ${request.request}`); + } + if (request.module) log(`${prefix}Request is an module request.`); + if (request.directory) log(`${prefix}Request is a directory request.`); + if (request.query) { + log(`${prefix}Resolving request query: ${request.query}`); + } + if (request.fragment) { + log(`${prefix}Resolving request fragment: ${request.fragment}`); + } + if (request.descriptionFilePath) { + log( + `${prefix}Has description data from ${request.descriptionFilePath}`, + ); + } + if (request.relativePath) { + log( + `${prefix}Relative path from description file is: ${request.relativePath}`, + ); + } + callback(); + }); + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/MainFieldPlugin.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/MainFieldPlugin.js new file mode 100644 index 0000000000000000000000000000000000000000..1a526816ff4dbc27c83b02c13750e9a2bd83870b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/MainFieldPlugin.js @@ -0,0 +1,87 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const path = require("path"); +const DescriptionFileUtils = require("./DescriptionFileUtils"); + +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").JsonObject} JsonObject */ +/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ +/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ + +/** @typedef {{name: string|Array, forceRelative: boolean}} MainFieldOptions */ + +const alreadyTriedMainField = Symbol("alreadyTriedMainField"); + +module.exports = class MainFieldPlugin { + /** + * @param {string | ResolveStepHook} source source + * @param {MainFieldOptions} options options + * @param {string | ResolveStepHook} target target + */ + constructor(source, options, target) { + this.source = source; + this.options = options; + this.target = target; + } + + /** + * @param {Resolver} resolver the resolver + * @returns {void} + */ + apply(resolver) { + const target = resolver.ensureHook(this.target); + resolver + .getHook(this.source) + .tapAsync("MainFieldPlugin", (request, resolveContext, callback) => { + if ( + request.path !== request.descriptionFileRoot || + /** @type {ResolveRequest & { [alreadyTriedMainField]?: string }} */ + (request)[alreadyTriedMainField] === request.descriptionFilePath || + !request.descriptionFilePath + ) { + return callback(); + } + const filename = path.basename(request.descriptionFilePath); + let mainModule = + /** @type {string|null|undefined} */ + ( + DescriptionFileUtils.getField( + /** @type {JsonObject} */ (request.descriptionFileData), + this.options.name, + ) + ); + + if ( + !mainModule || + typeof mainModule !== "string" || + mainModule === "." || + mainModule === "./" + ) { + return callback(); + } + if (this.options.forceRelative && !/^\.\.?\//.test(mainModule)) { + mainModule = `./${mainModule}`; + } + /** @type {ResolveRequest & { [alreadyTriedMainField]?: string }} */ + const obj = { + ...request, + request: mainModule, + module: false, + directory: mainModule.endsWith("/"), + [alreadyTriedMainField]: request.descriptionFilePath, + }; + return resolver.doResolve( + target, + obj, + `use ${mainModule} from ${this.options.name} in ${filename}`, + resolveContext, + callback, + ); + }); + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ModulesInHierachicDirectoriesPlugin.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ModulesInHierachicDirectoriesPlugin.js new file mode 100644 index 0000000000000000000000000000000000000000..06065e82c6b216628da2b6f57a84c79cfc75ae24 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ModulesInHierachicDirectoriesPlugin.js @@ -0,0 +1,9 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +// TODO remove in next major +module.exports = require("./ModulesInHierarchicalDirectoriesPlugin"); diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ModulesInHierarchicalDirectoriesPlugin.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ModulesInHierarchicalDirectoriesPlugin.js new file mode 100644 index 0000000000000000000000000000000000000000..8ed78cdbcf8e96476c59ba3e401aecf09ebf9d53 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ModulesInHierarchicalDirectoriesPlugin.js @@ -0,0 +1,91 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const forEachBail = require("./forEachBail"); +const getPaths = require("./getPaths"); + +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ +/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ + +module.exports = class ModulesInHierarchicalDirectoriesPlugin { + /** + * @param {string | ResolveStepHook} source source + * @param {string | Array} directories directories + * @param {string | ResolveStepHook} target target + */ + constructor(source, directories, target) { + this.source = source; + this.directories = /** @type {Array} */ [...directories]; + this.target = target; + } + + /** + * @param {Resolver} resolver the resolver + * @returns {void} + */ + apply(resolver) { + const target = resolver.ensureHook(this.target); + resolver + .getHook(this.source) + .tapAsync( + "ModulesInHierarchicalDirectoriesPlugin", + (request, resolveContext, callback) => { + const fs = resolver.fileSystem; + const addrs = getPaths(/** @type {string} */ (request.path)) + .paths.map((path) => + this.directories.map((directory) => + resolver.join(path, directory), + ), + ) + .reduce((array, path) => { + array.push(...path); + return array; + }, []); + forEachBail( + addrs, + /** + * @param {string} addr addr + * @param {(err?: null|Error, result?: null|ResolveRequest) => void} callback callback + * @returns {void} + */ + (addr, callback) => { + fs.stat(addr, (err, stat) => { + if (!err && stat && stat.isDirectory()) { + /** @type {ResolveRequest} */ + const obj = { + ...request, + path: addr, + request: `./${request.request}`, + module: false, + }; + const message = `looking for modules in ${addr}`; + return resolver.doResolve( + target, + obj, + message, + resolveContext, + callback, + ); + } + if (resolveContext.log) { + resolveContext.log( + `${addr} doesn't exist or is not a directory`, + ); + } + if (resolveContext.missingDependencies) { + resolveContext.missingDependencies.add(addr); + } + return callback(); + }); + }, + callback, + ); + }, + ); + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ModulesInRootPlugin.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ModulesInRootPlugin.js new file mode 100644 index 0000000000000000000000000000000000000000..7797a11e884a5b2a740da480db943e386510a162 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ModulesInRootPlugin.js @@ -0,0 +1,49 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ +/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ + +module.exports = class ModulesInRootPlugin { + /** + * @param {string | ResolveStepHook} source source + * @param {string} path path + * @param {string | ResolveStepHook} target target + */ + constructor(source, path, target) { + this.source = source; + this.path = path; + this.target = target; + } + + /** + * @param {Resolver} resolver the resolver + * @returns {void} + */ + apply(resolver) { + const target = resolver.ensureHook(this.target); + resolver + .getHook(this.source) + .tapAsync("ModulesInRootPlugin", (request, resolveContext, callback) => { + /** @type {ResolveRequest} */ + const obj = { + ...request, + path: this.path, + request: `./${request.request}`, + module: false, + }; + resolver.doResolve( + target, + obj, + `looking for modules in ${this.path}`, + resolveContext, + callback, + ); + }); + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/NextPlugin.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/NextPlugin.js new file mode 100644 index 0000000000000000000000000000000000000000..e59c56b8e04ba7abcc45d6232ea6e7890a1708bc --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/NextPlugin.js @@ -0,0 +1,33 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ + +module.exports = class NextPlugin { + /** + * @param {string | ResolveStepHook} source source + * @param {string | ResolveStepHook} target target + */ + constructor(source, target) { + this.source = source; + this.target = target; + } + + /** + * @param {Resolver} resolver the resolver + * @returns {void} + */ + apply(resolver) { + const target = resolver.ensureHook(this.target); + resolver + .getHook(this.source) + .tapAsync("NextPlugin", (request, resolveContext, callback) => { + resolver.doResolve(target, request, null, resolveContext, callback); + }); + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ParsePlugin.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ParsePlugin.js new file mode 100644 index 0000000000000000000000000000000000000000..c96c210bae8c18577ce6e8975dc8b12ecd7b82fb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ParsePlugin.js @@ -0,0 +1,77 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ +/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ + +module.exports = class ParsePlugin { + /** + * @param {string | ResolveStepHook} source source + * @param {Partial} requestOptions request options + * @param {string | ResolveStepHook} target target + */ + constructor(source, requestOptions, target) { + this.source = source; + this.requestOptions = requestOptions; + this.target = target; + } + + /** + * @param {Resolver} resolver the resolver + * @returns {void} + */ + apply(resolver) { + const target = resolver.ensureHook(this.target); + resolver + .getHook(this.source) + .tapAsync("ParsePlugin", (request, resolveContext, callback) => { + const parsed = resolver.parse(/** @type {string} */ (request.request)); + /** @type {ResolveRequest} */ + const obj = { ...request, ...parsed, ...this.requestOptions }; + if (request.query && !parsed.query) { + obj.query = request.query; + } + if (request.fragment && !parsed.fragment) { + obj.fragment = request.fragment; + } + if (parsed && resolveContext.log) { + if (parsed.module) resolveContext.log("Parsed request is a module"); + if (parsed.directory) { + resolveContext.log("Parsed request is a directory"); + } + } + // There is an edge-case where a request with # can be a path or a fragment -> try both + if (obj.request && !obj.query && obj.fragment) { + const directory = obj.fragment.endsWith("/"); + /** @type {ResolveRequest} */ + const alternative = { + ...obj, + directory, + request: + obj.request + + (obj.directory ? "/" : "") + + (directory ? obj.fragment.slice(0, -1) : obj.fragment), + fragment: "", + }; + resolver.doResolve( + target, + alternative, + null, + resolveContext, + (err, result) => { + if (err) return callback(err); + if (result) return callback(null, result); + resolver.doResolve(target, obj, null, resolveContext, callback); + }, + ); + return; + } + resolver.doResolve(target, obj, null, resolveContext, callback); + }); + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/PnpPlugin.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/PnpPlugin.js new file mode 100644 index 0000000000000000000000000000000000000000..9f767caba21610bd0b9f1e68c0003d5466e306b2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/PnpPlugin.js @@ -0,0 +1,134 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Maël Nison @arcanis +*/ + +"use strict"; + +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ +/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ +/** + * @typedef {object} PnpApiImpl + * @property {(packageName: string, issuer: string, options: { considerBuiltins: boolean }) => string | null} resolveToUnqualified resolve to unqualified + */ + +module.exports = class PnpPlugin { + /** + * @param {string | ResolveStepHook} source source + * @param {PnpApiImpl} pnpApi pnpApi + * @param {string | ResolveStepHook} target target + * @param {string | ResolveStepHook} alternateTarget alternateTarget + */ + constructor(source, pnpApi, target, alternateTarget) { + this.source = source; + this.pnpApi = pnpApi; + this.target = target; + this.alternateTarget = alternateTarget; + } + + /** + * @param {Resolver} resolver the resolver + * @returns {void} + */ + apply(resolver) { + /** @type {ResolveStepHook} */ + const target = resolver.ensureHook(this.target); + const alternateTarget = resolver.ensureHook(this.alternateTarget); + resolver + .getHook(this.source) + .tapAsync("PnpPlugin", (request, resolveContext, callback) => { + const req = request.request; + if (!req) return callback(); + + // The trailing slash indicates to PnP that this value is a folder rather than a file + const issuer = `${request.path}/`; + + const packageMatch = /^(@[^/]+\/)?[^/]+/.exec(req); + if (!packageMatch) return callback(); + + const [packageName] = packageMatch; + const innerRequest = `.${req.slice(packageName.length)}`; + + /** @type {string|undefined|null} */ + let resolution; + /** @type {string|undefined|null} */ + let apiResolution; + try { + resolution = this.pnpApi.resolveToUnqualified(packageName, issuer, { + considerBuiltins: false, + }); + + if (resolution === null) { + // This is either not a PnP managed issuer or it's a Node builtin + // Try to continue resolving with our alternatives + resolver.doResolve( + alternateTarget, + request, + "issuer is not managed by a pnpapi", + resolveContext, + (err, result) => { + if (err) return callback(err); + if (result) return callback(null, result); + // Skip alternatives + return callback(null, null); + }, + ); + return; + } + + if (resolveContext.fileDependencies) { + apiResolution = this.pnpApi.resolveToUnqualified("pnpapi", issuer, { + considerBuiltins: false, + }); + } + } catch (/** @type {unknown} */ error) { + if ( + /** @type {Error & { code: string }} */ + (error).code === "MODULE_NOT_FOUND" && + /** @type {Error & { pnpCode: string }} */ + (error).pnpCode === "UNDECLARED_DEPENDENCY" + ) { + // This is not a PnP managed dependency. + // Try to continue resolving with our alternatives + if (resolveContext.log) { + resolveContext.log("request is not managed by the pnpapi"); + for (const line of /** @type {Error} */ (error).message + .split("\n") + .filter(Boolean)) { + resolveContext.log(` ${line}`); + } + } + return callback(); + } + return callback(/** @type {Error} */ (error)); + } + + if (resolution === packageName) return callback(); + + if (apiResolution && resolveContext.fileDependencies) { + resolveContext.fileDependencies.add(apiResolution); + } + /** @type {ResolveRequest} */ + const obj = { + ...request, + path: resolution, + request: innerRequest, + ignoreSymlinks: true, + fullySpecified: request.fullySpecified && innerRequest !== ".", + }; + resolver.doResolve( + target, + obj, + `resolved by pnp to ${resolution}`, + resolveContext, + (err, result) => { + if (err) return callback(err); + if (result) return callback(null, result); + // Skip alternatives + return callback(null, null); + }, + ); + }); + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/Resolver.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/Resolver.js new file mode 100644 index 0000000000000000000000000000000000000000..8267ac2b56d767f73343bdd6e75c2e8f678cc097 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/Resolver.js @@ -0,0 +1,799 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const { AsyncSeriesBailHook, AsyncSeriesHook, SyncHook } = require("tapable"); +const createInnerContext = require("./createInnerContext"); +const { parseIdentifier } = require("./util/identifier"); +const { + PathType, + cachedJoin: join, + getType, + normalize, +} = require("./util/path"); + +/** @typedef {import("./ResolverFactory").ResolveOptions} ResolveOptions */ + +/** @typedef {Error & { details?: string }} ErrorWithDetail */ + +/** @typedef {(err: ErrorWithDetail | null, res?: string | false, req?: ResolveRequest) => void} ResolveCallback */ + +/** + * @typedef {object} PossibleFileSystemError + * @property {string=} code code + * @property {number=} errno number + * @property {string=} path path + * @property {string=} syscall syscall + */ + +/** + * @template T + * @callback FileSystemCallback + * @param {PossibleFileSystemError & Error | null} err + * @param {T=} result + */ + +/** + * @typedef {string | Buffer | URL} PathLike + */ + +/** + * @typedef {PathLike | number} PathOrFileDescriptor + */ + +/** + * @typedef {object} ObjectEncodingOptions + * @property {BufferEncoding | null | undefined=} encoding encoding + */ + +/** + * @typedef {ObjectEncodingOptions | BufferEncoding | undefined | null} EncodingOption + */ + +/** @typedef {(err: NodeJS.ErrnoException | null, result?: string) => void} StringCallback */ +/** @typedef {(err: NodeJS.ErrnoException | null, result?: Buffer) => void} BufferCallback */ +/** @typedef {(err: NodeJS.ErrnoException | null, result?: (string | Buffer)) => void} StringOrBufferCallback */ +/** @typedef {(err: NodeJS.ErrnoException | null, result?: IStats) => void} StatsCallback */ +/** @typedef {(err: NodeJS.ErrnoException | null, result?: IBigIntStats) => void} BigIntStatsCallback */ +/** @typedef {(err: NodeJS.ErrnoException | null, result?: (IStats | IBigIntStats)) => void} StatsOrBigIntStatsCallback */ +/** @typedef {(err: NodeJS.ErrnoException | Error | null, result?: JsonObject) => void} ReadJsonCallback */ + +/** + * @template T + * @typedef {object} IStatsBase + * @property {() => boolean} isFile is file + * @property {() => boolean} isDirectory is directory + * @property {() => boolean} isBlockDevice is block device + * @property {() => boolean} isCharacterDevice is character device + * @property {() => boolean} isSymbolicLink is symbolic link + * @property {() => boolean} isFIFO is FIFO + * @property {() => boolean} isSocket is socket + * @property {T} dev dev + * @property {T} ino ino + * @property {T} mode mode + * @property {T} nlink nlink + * @property {T} uid uid + * @property {T} gid gid + * @property {T} rdev rdev + * @property {T} size size + * @property {T} blksize blksize + * @property {T} blocks blocks + * @property {T} atimeMs atime ms + * @property {T} mtimeMs mtime ms + * @property {T} ctimeMs ctime ms + * @property {T} birthtimeMs birthtime ms + * @property {Date} atime atime + * @property {Date} mtime mtime + * @property {Date} ctime ctime + * @property {Date} birthtime birthtime + */ + +/** + * @typedef {IStatsBase} IStats + */ + +/** + * @typedef {IStatsBase & { atimeNs: bigint, mtimeNs: bigint, ctimeNs: bigint, birthtimeNs: bigint }} IBigIntStats + */ + +/** + * @template {string | Buffer} [T=string] + * @typedef {object} Dirent + * @property {() => boolean} isFile true when is file, otherwise false + * @property {() => boolean} isDirectory true when is directory, otherwise false + * @property {() => boolean} isBlockDevice true when is block device, otherwise false + * @property {() => boolean} isCharacterDevice true when is character device, otherwise false + * @property {() => boolean} isSymbolicLink true when is symbolic link, otherwise false + * @property {() => boolean} isFIFO true when is FIFO, otherwise false + * @property {() => boolean} isSocket true when is socket, otherwise false + * @property {T} name name + * @property {string} parentPath path + * @property {string=} path path + */ + +/** + * @typedef {object} StatOptions + * @property {(boolean | undefined)=} bigint need bigint values + */ + +/** + * @typedef {object} StatSyncOptions + * @property {(boolean | undefined)=} bigint need bigint values + * @property {(boolean | undefined)=} throwIfNoEntry throw if no entry + */ + +/** + * @typedef {{ + * (path: PathOrFileDescriptor, options: ({ encoding?: null | undefined, flag?: string | undefined } & import("events").Abortable) | undefined | null, callback: BufferCallback): void; + * (path: PathOrFileDescriptor, options: ({ encoding: BufferEncoding, flag?: string | undefined } & import("events").Abortable) | BufferEncoding, callback: StringCallback): void; + * (path: PathOrFileDescriptor, options: (ObjectEncodingOptions & { flag?: string | undefined } & import("events").Abortable) | BufferEncoding | undefined | null, callback: StringOrBufferCallback): void; + * (path: PathOrFileDescriptor, callback: BufferCallback): void; + * }} ReadFile + */ + +/** + * @typedef {'buffer'| { encoding: 'buffer' }} BufferEncodingOption + */ + +/** + * @typedef {{ + * (path: PathOrFileDescriptor, options?: { encoding?: null | undefined, flag?: string | undefined } | null): Buffer; + * (path: PathOrFileDescriptor, options: { encoding: BufferEncoding, flag?: string | undefined } | BufferEncoding): string; + * (path: PathOrFileDescriptor, options?: (ObjectEncodingOptions & { flag?: string | undefined }) | BufferEncoding | null): string | Buffer; + * }} ReadFileSync + */ + +/** + * @typedef {{ + * (path: PathLike, options: { encoding: BufferEncoding | null, withFileTypes?: false | undefined, recursive?: boolean | undefined } | BufferEncoding | undefined | null, callback: (err: NodeJS.ErrnoException | null, files?: string[]) => void): void; + * (path: PathLike, options: { encoding: 'buffer', withFileTypes?: false | undefined, recursive?: boolean | undefined } | 'buffer', callback: (err: NodeJS.ErrnoException | null, files?: Buffer[]) => void): void; + * (path: PathLike, options: (ObjectEncodingOptions & { withFileTypes?: false | undefined, recursive?: boolean | undefined }) | BufferEncoding | undefined | null, callback: (err: NodeJS.ErrnoException | null, files?: string[] | Buffer[]) => void): void; + * (path: PathLike, callback: (err: NodeJS.ErrnoException | null, files?: string[]) => void): void; + * (path: PathLike, options: ObjectEncodingOptions & { withFileTypes: true, recursive?: boolean | undefined }, callback: (err: NodeJS.ErrnoException | null, files?: Dirent[]) => void): void; + * (path: PathLike, options: { encoding: 'buffer', withFileTypes: true, recursive?: boolean | undefined }, callback: (err: NodeJS.ErrnoException | null, files: Dirent[]) => void): void; + * }} Readdir + */ + +/** + * @typedef {{ + * (path: PathLike, options?: { encoding: BufferEncoding | null, withFileTypes?: false | undefined, recursive?: boolean | undefined; } | BufferEncoding | null): string[]; + * (path: PathLike, options: { encoding: 'buffer', withFileTypes?: false | undefined, recursive?: boolean | undefined } | 'buffer'): Buffer[]; + * (path: PathLike, options?: (ObjectEncodingOptions & { withFileTypes?: false | undefined, recursive?: boolean | undefined }) | BufferEncoding | null): string[] | Buffer[]; + * (path: PathLike, options: ObjectEncodingOptions & { withFileTypes: true, recursive?: boolean | undefined }): Dirent[]; + * (path: PathLike, options: { encoding: "buffer", withFileTypes: true, recursive?: boolean | undefined }): Dirent[]; + * }} ReaddirSync + */ + +/** + * @typedef {(pathOrFileDescription: PathOrFileDescriptor, callback: ReadJsonCallback) => void} ReadJson + */ + +/** + * @typedef {(pathOrFileDescription: PathOrFileDescriptor) => JsonObject} ReadJsonSync + */ + +/** + * @typedef {{ + * (path: PathLike, options: EncodingOption, callback: StringCallback): void; + * (path: PathLike, options: BufferEncodingOption, callback: BufferCallback): void; + * (path: PathLike, options: EncodingOption, callback: StringOrBufferCallback): void; + * (path: PathLike, callback: StringCallback): void; + * }} Readlink + */ + +/** + * @typedef {{ + * (path: PathLike, options?: EncodingOption): string; + * (path: PathLike, options: BufferEncodingOption): Buffer; + * (path: PathLike, options?: EncodingOption): string | Buffer; + * }} ReadlinkSync + */ + +/** + * @typedef {{ + * (path: PathLike, callback: StatsCallback): void; + * (path: PathLike, options: (StatOptions & { bigint?: false | undefined }) | undefined, callback: StatsCallback): void; + * (path: PathLike, options: StatOptions & { bigint: true }, callback: BigIntStatsCallback): void; + * (path: PathLike, options: StatOptions | undefined, callback: StatsOrBigIntStatsCallback): void; + * }} LStat + */ + +/** + * @typedef {{ + * (path: PathLike, options?: undefined): IStats; + * (path: PathLike, options?: StatSyncOptions & { bigint?: false | undefined, throwIfNoEntry: false }): IStats | undefined; + * (path: PathLike, options: StatSyncOptions & { bigint: true, throwIfNoEntry: false }): IBigIntStats | undefined; + * (path: PathLike, options?: StatSyncOptions & { bigint?: false | undefined }): IStats; + * (path: PathLike, options: StatSyncOptions & { bigint: true }): IBigIntStats; + * (path: PathLike, options: StatSyncOptions & { bigint: boolean, throwIfNoEntry?: false | undefined }): IStats | IBigIntStats; + * (path: PathLike, options?: StatSyncOptions): IStats | IBigIntStats | undefined; + * }} LStatSync + */ + +/** + * @typedef {{ + * (path: PathLike, callback: StatsCallback): void; + * (path: PathLike, options: (StatOptions & { bigint?: false | undefined }) | undefined, callback: StatsCallback): void; + * (path: PathLike, options: StatOptions & { bigint: true }, callback: BigIntStatsCallback): void; + * (path: PathLike, options: StatOptions | undefined, callback: StatsOrBigIntStatsCallback): void; + * }} Stat + */ + +/** + * @typedef {{ + * (path: PathLike, options?: undefined): IStats; + * (path: PathLike, options?: StatSyncOptions & { bigint?: false | undefined, throwIfNoEntry: false }): IStats | undefined; + * (path: PathLike, options: StatSyncOptions & { bigint: true, throwIfNoEntry: false }): IBigIntStats | undefined; + * (path: PathLike, options?: StatSyncOptions & { bigint?: false | undefined }): IStats; + * (path: PathLike, options: StatSyncOptions & { bigint: true }): IBigIntStats; + * (path: PathLike, options: StatSyncOptions & { bigint: boolean, throwIfNoEntry?: false | undefined }): IStats | IBigIntStats; + * (path: PathLike, options?: StatSyncOptions): IStats | IBigIntStats | undefined; + * }} StatSync + */ + +/** + * @typedef {{ + * (path: PathLike, options: EncodingOption, callback: StringCallback): void; + * (path: PathLike, options: BufferEncodingOption, callback: BufferCallback): void; + * (path: PathLike, options: EncodingOption, callback: StringOrBufferCallback): void; + * (path: PathLike, callback: StringCallback): void; + * }} RealPath + */ + +/** + * @typedef {{ + * (path: PathLike, options?: EncodingOption): string; + * (path: PathLike, options: BufferEncodingOption): Buffer; + * (path: PathLike, options?: EncodingOption): string | Buffer; + * }} RealPathSync + */ + +/** + * @typedef {object} FileSystem + * @property {ReadFile} readFile read file method + * @property {Readdir} readdir readdir method + * @property {ReadJson=} readJson read json method + * @property {Readlink} readlink read link method + * @property {LStat=} lstat lstat method + * @property {Stat} stat stat method + * @property {RealPath=} realpath realpath method + */ + +/** + * @typedef {object} SyncFileSystem + * @property {ReadFileSync} readFileSync read file sync method + * @property {ReaddirSync} readdirSync read dir sync method + * @property {ReadJsonSync=} readJsonSync read json sync method + * @property {ReadlinkSync} readlinkSync read link sync method + * @property {LStatSync=} lstatSync lstat sync method + * @property {StatSync} statSync stat sync method + * @property {RealPathSync=} realpathSync real path sync method + */ + +/** + * @typedef {object} ParsedIdentifier + * @property {string} request request + * @property {string} query query + * @property {string} fragment fragment + * @property {boolean} directory is directory + * @property {boolean} module is module + * @property {boolean} file is file + * @property {boolean} internal is internal + */ + +/** @typedef {string | number | boolean | null} JsonPrimitive */ +/** @typedef {JsonValue[]} JsonArray */ +/** @typedef {JsonPrimitive | JsonObject | JsonArray} JsonValue */ +/** @typedef {{ [Key in string]?: JsonValue | undefined }} JsonObject */ + +// eslint-disable-next-line jsdoc/require-property +/** @typedef {object} Context */ + +/** + * @typedef {object} BaseResolveRequest + * @property {string | false} path path + * @property {Context=} context content + * @property {string=} descriptionFilePath description file path + * @property {string=} descriptionFileRoot description file root + * @property {JsonObject=} descriptionFileData description file data + * @property {string=} relativePath relative path + * @property {boolean=} ignoreSymlinks true when need to ignore symlinks, otherwise false + * @property {boolean=} fullySpecified true when full specified, otherwise false + * @property {string=} __innerRequest inner request for internal usage + * @property {string=} __innerRequest_request inner request for internal usage + * @property {string=} __innerRequest_relativePath inner relative path for internal usage + */ + +/** @typedef {BaseResolveRequest & Partial} ResolveRequest */ + +/** + * String with special formatting + * @typedef {string} StackEntry + */ + +/** + * @template T + * @typedef {{ add: (item: T) => void }} WriteOnlySet + */ + +/** @typedef {(request: ResolveRequest) => void} ResolveContextYield */ + +/** + * Resolve context + * @typedef {object} ResolveContext + * @property {WriteOnlySet=} contextDependencies directories that was found on file system + * @property {WriteOnlySet=} fileDependencies files that was found on file system + * @property {WriteOnlySet=} missingDependencies dependencies that was not found on file system + * @property {Set=} stack set of hooks' calls. For instance, `resolve → parsedResolve → describedResolve`, + * @property {((str: string) => void)=} log log function + * @property {ResolveContextYield=} yield yield result, if provided plugins can return several results + */ + +/** @typedef {AsyncSeriesBailHook<[ResolveRequest, ResolveContext], ResolveRequest | null>} ResolveStepHook */ + +/** + * @typedef {object} KnownHooks + * @property {SyncHook<[ResolveStepHook, ResolveRequest], void>} resolveStep resolve step hook + * @property {SyncHook<[ResolveRequest, Error]>} noResolve no resolve hook + * @property {ResolveStepHook} resolve resolve hook + * @property {AsyncSeriesHook<[ResolveRequest, ResolveContext]>} result result hook + */ + +/** + * @typedef {{[key: string]: ResolveStepHook}} EnsuredHooks + */ + +/** + * @param {string} str input string + * @returns {string} in camel case + */ +function toCamelCase(str) { + return str.replace(/-([a-z])/g, (str) => str.slice(1).toUpperCase()); +} + +class Resolver { + /** + * @param {ResolveStepHook} hook hook + * @param {ResolveRequest} request request + * @returns {StackEntry} stack entry + */ + static createStackEntry(hook, request) { + return `${hook.name}: (${request.path}) ${request.request || ""}${ + request.query || "" + }${request.fragment || ""}${request.directory ? " directory" : ""}${ + request.module ? " module" : "" + }`; + } + + /** + * @param {FileSystem} fileSystem a filesystem + * @param {ResolveOptions} options options + */ + constructor(fileSystem, options) { + this.fileSystem = fileSystem; + this.options = options; + /** @type {KnownHooks} */ + this.hooks = { + resolveStep: new SyncHook(["hook", "request"], "resolveStep"), + noResolve: new SyncHook(["request", "error"], "noResolve"), + resolve: new AsyncSeriesBailHook( + ["request", "resolveContext"], + "resolve", + ), + result: new AsyncSeriesHook(["result", "resolveContext"], "result"), + }; + } + + /** + * @param {string | ResolveStepHook} name hook name or hook itself + * @returns {ResolveStepHook} the hook + */ + ensureHook(name) { + if (typeof name !== "string") { + return name; + } + name = toCamelCase(name); + if (name.startsWith("before")) { + return /** @type {ResolveStepHook} */ ( + this.ensureHook(name[6].toLowerCase() + name.slice(7)).withOptions({ + stage: -10, + }) + ); + } + if (name.startsWith("after")) { + return /** @type {ResolveStepHook} */ ( + this.ensureHook(name[5].toLowerCase() + name.slice(6)).withOptions({ + stage: 10, + }) + ); + } + /** @type {ResolveStepHook} */ + const hook = /** @type {KnownHooks & EnsuredHooks} */ (this.hooks)[name]; + if (!hook) { + /** @type {KnownHooks & EnsuredHooks} */ + (this.hooks)[name] = new AsyncSeriesBailHook( + ["request", "resolveContext"], + name, + ); + + return /** @type {KnownHooks & EnsuredHooks} */ (this.hooks)[name]; + } + return hook; + } + + /** + * @param {string | ResolveStepHook} name hook name or hook itself + * @returns {ResolveStepHook} the hook + */ + getHook(name) { + if (typeof name !== "string") { + return name; + } + name = toCamelCase(name); + if (name.startsWith("before")) { + return /** @type {ResolveStepHook} */ ( + this.getHook(name[6].toLowerCase() + name.slice(7)).withOptions({ + stage: -10, + }) + ); + } + if (name.startsWith("after")) { + return /** @type {ResolveStepHook} */ ( + this.getHook(name[5].toLowerCase() + name.slice(6)).withOptions({ + stage: 10, + }) + ); + } + /** @type {ResolveStepHook} */ + const hook = /** @type {KnownHooks & EnsuredHooks} */ (this.hooks)[name]; + if (!hook) { + throw new Error(`Hook ${name} doesn't exist`); + } + return hook; + } + + /** + * @param {object} context context information object + * @param {string} path context path + * @param {string} request request string + * @returns {string | false} result + */ + resolveSync(context, path, request) { + /** @type {Error | null | undefined} */ + let err; + /** @type {string | false | undefined} */ + let result; + let sync = false; + this.resolve(context, path, request, {}, (_err, r) => { + err = _err; + result = r; + sync = true; + }); + if (!sync) { + throw new Error( + "Cannot 'resolveSync' because the fileSystem is not sync. Use 'resolve'!", + ); + } + if (err) throw err; + if (result === undefined) throw new Error("No result"); + return result; + } + + /** + * @param {object} context context information object + * @param {string} path context path + * @param {string} request request string + * @param {ResolveContext} resolveContext resolve context + * @param {ResolveCallback} callback callback function + * @returns {void} + */ + resolve(context, path, request, resolveContext, callback) { + if (!context || typeof context !== "object") { + return callback(new Error("context argument is not an object")); + } + if (typeof path !== "string") { + return callback(new Error("path argument is not a string")); + } + if (typeof request !== "string") { + return callback(new Error("request argument is not a string")); + } + if (!resolveContext) { + return callback(new Error("resolveContext argument is not set")); + } + + /** @type {ResolveRequest} */ + const obj = { + context, + path, + request, + }; + + /** @type {ResolveContextYield | undefined} */ + let yield_; + let yieldCalled = false; + /** @type {ResolveContextYield | undefined} */ + let finishYield; + if (typeof resolveContext.yield === "function") { + const old = resolveContext.yield; + /** + * @param {ResolveRequest} obj object + */ + yield_ = (obj) => { + old(obj); + yieldCalled = true; + }; + /** + * @param {ResolveRequest} result result + * @returns {void} + */ + finishYield = (result) => { + if (result) { + /** @type {ResolveContextYield} */ (yield_)(result); + } + callback(null); + }; + } + + const message = `resolve '${request}' in '${path}'`; + + /** + * @param {ResolveRequest} result result + * @returns {void} + */ + const finishResolved = (result) => + callback( + null, + result.path === false + ? false + : `${result.path.replace(/#/g, "\0#")}${ + result.query ? result.query.replace(/#/g, "\0#") : "" + }${result.fragment || ""}`, + result, + ); + + /** + * @param {string[]} log logs + * @returns {void} + */ + const finishWithoutResolve = (log) => { + /** + * @type {ErrorWithDetail} + */ + const error = new Error(`Can't ${message}`); + error.details = log.join("\n"); + this.hooks.noResolve.call(obj, error); + return callback(error); + }; + + if (resolveContext.log) { + // We need log anyway to capture it in case of an error + const parentLog = resolveContext.log; + /** @type {string[]} */ + const log = []; + return this.doResolve( + this.hooks.resolve, + obj, + message, + { + log: (msg) => { + parentLog(msg); + log.push(msg); + }, + yield: yield_, + fileDependencies: resolveContext.fileDependencies, + contextDependencies: resolveContext.contextDependencies, + missingDependencies: resolveContext.missingDependencies, + stack: resolveContext.stack, + }, + (err, result) => { + if (err) return callback(err); + + if (yieldCalled || (result && yield_)) { + return /** @type {ResolveContextYield} */ (finishYield)( + /** @type {ResolveRequest} */ (result), + ); + } + + if (result) return finishResolved(result); + + return finishWithoutResolve(log); + }, + ); + } + // Try to resolve assuming there is no error + // We don't log stuff in this case + return this.doResolve( + this.hooks.resolve, + obj, + message, + { + log: undefined, + yield: yield_, + fileDependencies: resolveContext.fileDependencies, + contextDependencies: resolveContext.contextDependencies, + missingDependencies: resolveContext.missingDependencies, + stack: resolveContext.stack, + }, + (err, result) => { + if (err) return callback(err); + + if (yieldCalled || (result && yield_)) { + return /** @type {ResolveContextYield} */ (finishYield)( + /** @type {ResolveRequest} */ (result), + ); + } + + if (result) return finishResolved(result); + + // log is missing for the error details + // so we redo the resolving for the log info + // this is more expensive to the success case + // is assumed by default + /** @type {string[]} */ + const log = []; + + return this.doResolve( + this.hooks.resolve, + obj, + message, + { + log: (msg) => log.push(msg), + yield: yield_, + stack: resolveContext.stack, + }, + (err, result) => { + if (err) return callback(err); + + // In a case that there is a race condition and yield will be called + if (yieldCalled || (result && yield_)) { + return /** @type {ResolveContextYield} */ (finishYield)( + /** @type {ResolveRequest} */ (result), + ); + } + + return finishWithoutResolve(log); + }, + ); + }, + ); + } + + /** + * @param {ResolveStepHook} hook hook + * @param {ResolveRequest} request request + * @param {null|string} message string + * @param {ResolveContext} resolveContext resolver context + * @param {(err?: null|Error, result?: ResolveRequest) => void} callback callback + * @returns {void} + */ + doResolve(hook, request, message, resolveContext, callback) { + const stackEntry = Resolver.createStackEntry(hook, request); + + /** @type {Set | undefined} */ + let newStack; + if (resolveContext.stack) { + newStack = new Set(resolveContext.stack); + if (resolveContext.stack.has(stackEntry)) { + /** + * Prevent recursion + * @type {Error & {recursion?: boolean}} + */ + const recursionError = new Error( + `Recursion in resolving\nStack:\n ${[...newStack].join("\n ")}`, + ); + recursionError.recursion = true; + if (resolveContext.log) { + resolveContext.log("abort resolving because of recursion"); + } + return callback(recursionError); + } + newStack.add(stackEntry); + } else { + // creating a set with new Set([item]) + // allocates a new array that has to be garbage collected + // this is an EXTREMELY hot path, so let's avoid it + newStack = new Set(); + newStack.add(stackEntry); + } + this.hooks.resolveStep.call(hook, request); + + if (hook.isUsed()) { + const innerContext = createInnerContext( + { + log: resolveContext.log, + yield: resolveContext.yield, + fileDependencies: resolveContext.fileDependencies, + contextDependencies: resolveContext.contextDependencies, + missingDependencies: resolveContext.missingDependencies, + stack: newStack, + }, + message, + ); + return hook.callAsync(request, innerContext, (err, result) => { + if (err) return callback(err); + if (result) return callback(null, result); + callback(); + }); + } + callback(); + } + + /** + * @param {string} identifier identifier + * @returns {ParsedIdentifier} parsed identifier + */ + parse(identifier) { + const part = { + request: "", + query: "", + fragment: "", + module: false, + directory: false, + file: false, + internal: false, + }; + + const parsedIdentifier = parseIdentifier(identifier); + + if (!parsedIdentifier) return part; + + [part.request, part.query, part.fragment] = parsedIdentifier; + + if (part.request.length > 0) { + part.internal = this.isPrivate(identifier); + part.module = this.isModule(part.request); + part.directory = this.isDirectory(part.request); + if (part.directory) { + part.request = part.request.slice(0, -1); + } + } + + return part; + } + + /** + * @param {string} path path + * @returns {boolean} true, if the path is a module + */ + isModule(path) { + return getType(path) === PathType.Normal; + } + + /** + * @param {string} path path + * @returns {boolean} true, if the path is private + */ + isPrivate(path) { + return getType(path) === PathType.Internal; + } + + /** + * @param {string} path a path + * @returns {boolean} true, if the path is a directory path + */ + isDirectory(path) { + return path.endsWith("/"); + } + + /** + * @param {string} path path + * @param {string} request request + * @returns {string} joined path + */ + join(path, request) { + return join(path, request); + } + + /** + * @param {string} path path + * @returns {string} normalized path + */ + normalize(path) { + return normalize(path); + } +} + +module.exports = Resolver; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ResolverFactory.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ResolverFactory.js new file mode 100644 index 0000000000000000000000000000000000000000..266dd695910a23cfa8b4764ee0754f494bd7dc44 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ResolverFactory.js @@ -0,0 +1,731 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +// eslint-disable-next-line n/prefer-global/process +const { versions } = require("process"); + +const AliasFieldPlugin = require("./AliasFieldPlugin"); +const AliasPlugin = require("./AliasPlugin"); +const AppendPlugin = require("./AppendPlugin"); +const ConditionalPlugin = require("./ConditionalPlugin"); +const DescriptionFilePlugin = require("./DescriptionFilePlugin"); +const DirectoryExistsPlugin = require("./DirectoryExistsPlugin"); +const ExportsFieldPlugin = require("./ExportsFieldPlugin"); +const ExtensionAliasPlugin = require("./ExtensionAliasPlugin"); +const FileExistsPlugin = require("./FileExistsPlugin"); +const ImportsFieldPlugin = require("./ImportsFieldPlugin"); +const JoinRequestPartPlugin = require("./JoinRequestPartPlugin"); +const JoinRequestPlugin = require("./JoinRequestPlugin"); +const MainFieldPlugin = require("./MainFieldPlugin"); +const ModulesInHierarchicalDirectoriesPlugin = require("./ModulesInHierarchicalDirectoriesPlugin"); +const ModulesInRootPlugin = require("./ModulesInRootPlugin"); +const NextPlugin = require("./NextPlugin"); +const ParsePlugin = require("./ParsePlugin"); +const PnpPlugin = require("./PnpPlugin"); +const Resolver = require("./Resolver"); +const RestrictionsPlugin = require("./RestrictionsPlugin"); +const ResultPlugin = require("./ResultPlugin"); +const RootsPlugin = require("./RootsPlugin"); +const SelfReferencePlugin = require("./SelfReferencePlugin"); +const SymlinkPlugin = require("./SymlinkPlugin"); +const SyncAsyncFileSystemDecorator = require("./SyncAsyncFileSystemDecorator"); +const TryNextPlugin = require("./TryNextPlugin"); +const UnsafeCachePlugin = require("./UnsafeCachePlugin"); +const UseFilePlugin = require("./UseFilePlugin"); +const { PathType, getType } = require("./util/path"); + +/** @typedef {import("./AliasPlugin").AliasOption} AliasOptionEntry */ +/** @typedef {import("./ExtensionAliasPlugin").ExtensionAliasOption} ExtensionAliasOption */ +/** @typedef {import("./PnpPlugin").PnpApiImpl} PnpApi */ +/** @typedef {import("./Resolver").EnsuredHooks} EnsuredHooks */ +/** @typedef {import("./Resolver").FileSystem} FileSystem */ +/** @typedef {import("./Resolver").KnownHooks} KnownHooks */ +/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ +/** @typedef {import("./Resolver").SyncFileSystem} SyncFileSystem */ +/** @typedef {import("./UnsafeCachePlugin").Cache} Cache */ + +/** @typedef {string | string[] | false} AliasOptionNewRequest */ +/** @typedef {{ [k: string]: AliasOptionNewRequest }} AliasOptions */ +/** @typedef {{ [k: string]: string|string[] }} ExtensionAliasOptions */ +/** @typedef {false | 0 | "" | null | undefined} Falsy */ +/** @typedef {{apply: (resolver: Resolver) => void} | ((this: Resolver, resolver: Resolver) => void) | Falsy} Plugin */ + +/** + * @typedef {object} UserResolveOptions + * @property {(AliasOptions | AliasOptionEntry[])=} alias A list of module alias configurations or an object which maps key to value + * @property {(AliasOptions | AliasOptionEntry[])=} fallback A list of module alias configurations or an object which maps key to value, applied only after modules option + * @property {ExtensionAliasOptions=} extensionAlias An object which maps extension to extension aliases + * @property {(string | string[])[]=} aliasFields A list of alias fields in description files + * @property {((predicate: ResolveRequest) => boolean)=} cachePredicate A function which decides whether a request should be cached or not. An object is passed with at least `path` and `request` properties. + * @property {boolean=} cacheWithContext Whether or not the unsafeCache should include request context as part of the cache key. + * @property {string[]=} descriptionFiles A list of description files to read from + * @property {string[]=} conditionNames A list of exports field condition names. + * @property {boolean=} enforceExtension Enforce that a extension from extensions must be used + * @property {(string | string[])[]=} exportsFields A list of exports fields in description files + * @property {(string | string[])[]=} importsFields A list of imports fields in description files + * @property {string[]=} extensions A list of extensions which should be tried for files + * @property {FileSystem} fileSystem The file system which should be used + * @property {(Cache | boolean)=} unsafeCache Use this cache object to unsafely cache the successful requests + * @property {boolean=} symlinks Resolve symlinks to their symlinked location + * @property {Resolver=} resolver A prepared Resolver to which the plugins are attached + * @property {string[] | string=} modules A list of directories to resolve modules from, can be absolute path or folder name + * @property {(string | string[] | {name: string | string[], forceRelative: boolean})[]=} mainFields A list of main fields in description files + * @property {string[]=} mainFiles A list of main files in directories + * @property {Plugin[]=} plugins A list of additional resolve plugins which should be applied + * @property {PnpApi | null=} pnpApi A PnP API that should be used - null is "never", undefined is "auto" + * @property {string[]=} roots A list of root paths + * @property {boolean=} fullySpecified The request is already fully specified and no extensions or directories are resolved for it + * @property {boolean=} resolveToContext Resolve to a context instead of a file + * @property {(string|RegExp)[]=} restrictions A list of resolve restrictions + * @property {boolean=} useSyncFileSystemCalls Use only the sync constraints of the file system calls + * @property {boolean=} preferRelative Prefer to resolve module requests as relative requests before falling back to modules + * @property {boolean=} preferAbsolute Prefer to resolve server-relative urls as absolute paths before falling back to resolve in roots + */ + +/** + * @typedef {object} ResolveOptions + * @property {AliasOptionEntry[]} alias alias + * @property {AliasOptionEntry[]} fallback fallback + * @property {Set} aliasFields alias fields + * @property {ExtensionAliasOption[]} extensionAlias extension alias + * @property {(predicate: ResolveRequest) => boolean} cachePredicate cache predicate + * @property {boolean} cacheWithContext cache with context + * @property {Set} conditionNames A list of exports field condition names. + * @property {string[]} descriptionFiles description files + * @property {boolean} enforceExtension enforce extension + * @property {Set} exportsFields exports fields + * @property {Set} importsFields imports fields + * @property {Set} extensions extensions + * @property {FileSystem} fileSystem fileSystem + * @property {Cache | false} unsafeCache unsafe cache + * @property {boolean} symlinks symlinks + * @property {Resolver=} resolver resolver + * @property {Array} modules modules + * @property {{ name: string[], forceRelative: boolean }[]} mainFields main fields + * @property {Set} mainFiles main files + * @property {Plugin[]} plugins plugins + * @property {PnpApi | null} pnpApi pnp API + * @property {Set} roots roots + * @property {boolean} fullySpecified fully specified + * @property {boolean} resolveToContext resolve to context + * @property {Set} restrictions restrictions + * @property {boolean} preferRelative prefer relative + * @property {boolean} preferAbsolute prefer absolute + */ + +/** + * @param {PnpApi | null=} option option + * @returns {PnpApi | null} processed option + */ +function processPnpApiOption(option) { + if ( + option === undefined && + /** @type {NodeJS.ProcessVersions & {pnp: string}} */ versions.pnp + ) { + const _findPnpApi = + /** @type {(issuer: string) => PnpApi | null}} */ + ( + // @ts-expect-error maybe nothing + require("module").findPnpApi + ); + + if (_findPnpApi) { + return { + resolveToUnqualified(request, issuer, opts) { + const pnpapi = _findPnpApi(issuer); + + if (!pnpapi) { + // Issuer isn't managed by PnP + return null; + } + + return pnpapi.resolveToUnqualified(request, issuer, opts); + }, + }; + } + } + + return option || null; +} + +/** + * @param {AliasOptions | AliasOptionEntry[] | undefined} alias alias + * @returns {AliasOptionEntry[]} normalized aliases + */ +function normalizeAlias(alias) { + return typeof alias === "object" && !Array.isArray(alias) && alias !== null + ? Object.keys(alias).map((key) => { + /** @type {AliasOptionEntry} */ + const obj = { name: key, onlyModule: false, alias: alias[key] }; + + if (/\$$/.test(key)) { + obj.onlyModule = true; + obj.name = key.slice(0, -1); + } + + return obj; + }) + : /** @type {Array} */ (alias) || []; +} + +/** + * Merging filtered elements + * @param {string[]} array source array + * @param {(item: string) => boolean} filter predicate + * @returns {Array} merge result + */ +function mergeFilteredToArray(array, filter) { + /** @type {Array} */ + const result = []; + const set = new Set(array); + + for (const item of set) { + if (filter(item)) { + const lastElement = + result.length > 0 ? result[result.length - 1] : undefined; + if (Array.isArray(lastElement)) { + lastElement.push(item); + } else { + result.push([item]); + } + } else { + result.push(item); + } + } + + return result; +} + +/** + * @param {UserResolveOptions} options input options + * @returns {ResolveOptions} output options + */ +function createOptions(options) { + const mainFieldsSet = new Set(options.mainFields || ["main"]); + /** @type {ResolveOptions["mainFields"]} */ + const mainFields = []; + + for (const item of mainFieldsSet) { + if (typeof item === "string") { + mainFields.push({ + name: [item], + forceRelative: true, + }); + } else if (Array.isArray(item)) { + mainFields.push({ + name: item, + forceRelative: true, + }); + } else { + mainFields.push({ + name: Array.isArray(item.name) ? item.name : [item.name], + forceRelative: item.forceRelative, + }); + } + } + + return { + alias: normalizeAlias(options.alias), + fallback: normalizeAlias(options.fallback), + aliasFields: new Set(options.aliasFields), + cachePredicate: + options.cachePredicate || + function trueFn() { + return true; + }, + cacheWithContext: + typeof options.cacheWithContext !== "undefined" + ? options.cacheWithContext + : true, + exportsFields: new Set(options.exportsFields || ["exports"]), + importsFields: new Set(options.importsFields || ["imports"]), + conditionNames: new Set(options.conditionNames), + descriptionFiles: [ + ...new Set(options.descriptionFiles || ["package.json"]), + ], + enforceExtension: + options.enforceExtension === undefined + ? Boolean(options.extensions && options.extensions.includes("")) + : options.enforceExtension, + extensions: new Set(options.extensions || [".js", ".json", ".node"]), + extensionAlias: options.extensionAlias + ? Object.keys(options.extensionAlias).map((k) => ({ + extension: k, + alias: /** @type {ExtensionAliasOptions} */ (options.extensionAlias)[ + k + ], + })) + : [], + fileSystem: options.useSyncFileSystemCalls + ? new SyncAsyncFileSystemDecorator( + /** @type {SyncFileSystem} */ ( + /** @type {unknown} */ (options.fileSystem) + ), + ) + : options.fileSystem, + unsafeCache: + options.unsafeCache && typeof options.unsafeCache !== "object" + ? /** @type {Cache} */ ({}) + : options.unsafeCache || false, + symlinks: typeof options.symlinks !== "undefined" ? options.symlinks : true, + resolver: options.resolver, + modules: mergeFilteredToArray( + Array.isArray(options.modules) + ? options.modules + : options.modules + ? [options.modules] + : ["node_modules"], + (item) => { + const type = getType(item); + return type === PathType.Normal || type === PathType.Relative; + }, + ), + mainFields, + mainFiles: new Set(options.mainFiles || ["index"]), + plugins: options.plugins || [], + pnpApi: processPnpApiOption(options.pnpApi), + roots: new Set(options.roots || undefined), + fullySpecified: options.fullySpecified || false, + resolveToContext: options.resolveToContext || false, + preferRelative: options.preferRelative || false, + preferAbsolute: options.preferAbsolute || false, + restrictions: new Set(options.restrictions), + }; +} + +/** + * @param {UserResolveOptions} options resolve options + * @returns {Resolver} created resolver + */ +module.exports.createResolver = function createResolver(options) { + const normalizedOptions = createOptions(options); + + const { + alias, + fallback, + aliasFields, + cachePredicate, + cacheWithContext, + conditionNames, + descriptionFiles, + enforceExtension, + exportsFields, + extensionAlias, + importsFields, + extensions, + fileSystem, + fullySpecified, + mainFields, + mainFiles, + modules, + plugins: userPlugins, + pnpApi, + resolveToContext, + preferRelative, + preferAbsolute, + symlinks, + unsafeCache, + resolver: customResolver, + restrictions, + roots, + } = normalizedOptions; + + const plugins = [...userPlugins]; + + const resolver = + customResolver || new Resolver(fileSystem, normalizedOptions); + + // // pipeline //// + + resolver.ensureHook("resolve"); + resolver.ensureHook("internalResolve"); + resolver.ensureHook("newInternalResolve"); + resolver.ensureHook("parsedResolve"); + resolver.ensureHook("describedResolve"); + resolver.ensureHook("rawResolve"); + resolver.ensureHook("normalResolve"); + resolver.ensureHook("internal"); + resolver.ensureHook("rawModule"); + resolver.ensureHook("alternateRawModule"); + resolver.ensureHook("module"); + resolver.ensureHook("resolveAsModule"); + resolver.ensureHook("undescribedResolveInPackage"); + resolver.ensureHook("resolveInPackage"); + resolver.ensureHook("resolveInExistingDirectory"); + resolver.ensureHook("relative"); + resolver.ensureHook("describedRelative"); + resolver.ensureHook("directory"); + resolver.ensureHook("undescribedExistingDirectory"); + resolver.ensureHook("existingDirectory"); + resolver.ensureHook("undescribedRawFile"); + resolver.ensureHook("rawFile"); + resolver.ensureHook("file"); + resolver.ensureHook("finalFile"); + resolver.ensureHook("existingFile"); + resolver.ensureHook("resolved"); + + // TODO remove in next major + // cspell:word Interal + // Backward-compat + // @ts-expect-error + resolver.hooks.newInteralResolve = resolver.hooks.newInternalResolve; + + // resolve + for (const { source, resolveOptions } of [ + { source: "resolve", resolveOptions: { fullySpecified } }, + { source: "internal-resolve", resolveOptions: { fullySpecified: false } }, + ]) { + if (unsafeCache) { + plugins.push( + new UnsafeCachePlugin( + source, + cachePredicate, + /** @type {import("./UnsafeCachePlugin").Cache} */ (unsafeCache), + cacheWithContext, + `new-${source}`, + ), + ); + plugins.push( + new ParsePlugin(`new-${source}`, resolveOptions, "parsed-resolve"), + ); + } else { + plugins.push(new ParsePlugin(source, resolveOptions, "parsed-resolve")); + } + } + + // parsed-resolve + plugins.push( + new DescriptionFilePlugin( + "parsed-resolve", + descriptionFiles, + false, + "described-resolve", + ), + ); + plugins.push(new NextPlugin("after-parsed-resolve", "described-resolve")); + + // described-resolve + plugins.push(new NextPlugin("described-resolve", "raw-resolve")); + if (fallback.length > 0) { + plugins.push( + new AliasPlugin("described-resolve", fallback, "internal-resolve"), + ); + } + + // raw-resolve + if (alias.length > 0) { + plugins.push(new AliasPlugin("raw-resolve", alias, "internal-resolve")); + } + for (const item of aliasFields) { + plugins.push(new AliasFieldPlugin("raw-resolve", item, "internal-resolve")); + } + for (const item of extensionAlias) { + plugins.push( + new ExtensionAliasPlugin("raw-resolve", item, "normal-resolve"), + ); + } + plugins.push(new NextPlugin("raw-resolve", "normal-resolve")); + + // normal-resolve + if (preferRelative) { + plugins.push(new JoinRequestPlugin("after-normal-resolve", "relative")); + } + plugins.push( + new ConditionalPlugin( + "after-normal-resolve", + { module: true }, + "resolve as module", + false, + "raw-module", + ), + ); + plugins.push( + new ConditionalPlugin( + "after-normal-resolve", + { internal: true }, + "resolve as internal import", + false, + "internal", + ), + ); + if (preferAbsolute) { + plugins.push(new JoinRequestPlugin("after-normal-resolve", "relative")); + } + if (roots.size > 0) { + plugins.push(new RootsPlugin("after-normal-resolve", roots, "relative")); + } + if (!preferRelative && !preferAbsolute) { + plugins.push(new JoinRequestPlugin("after-normal-resolve", "relative")); + } + + // internal + for (const importsField of importsFields) { + plugins.push( + new ImportsFieldPlugin( + "internal", + conditionNames, + importsField, + "relative", + "internal-resolve", + ), + ); + } + + // raw-module + for (const exportsField of exportsFields) { + plugins.push( + new SelfReferencePlugin("raw-module", exportsField, "resolve-as-module"), + ); + } + for (const item of modules) { + if (Array.isArray(item)) { + if (item.includes("node_modules") && pnpApi) { + plugins.push( + new ModulesInHierarchicalDirectoriesPlugin( + "raw-module", + item.filter((i) => i !== "node_modules"), + "module", + ), + ); + plugins.push( + new PnpPlugin( + "raw-module", + pnpApi, + "undescribed-resolve-in-package", + "alternate-raw-module", + ), + ); + + plugins.push( + new ModulesInHierarchicalDirectoriesPlugin( + "alternate-raw-module", + ["node_modules"], + "module", + ), + ); + } else { + plugins.push( + new ModulesInHierarchicalDirectoriesPlugin( + "raw-module", + item, + "module", + ), + ); + } + } else { + plugins.push(new ModulesInRootPlugin("raw-module", item, "module")); + } + } + + // module + plugins.push(new JoinRequestPartPlugin("module", "resolve-as-module")); + + // resolve-as-module + if (!resolveToContext) { + plugins.push( + new ConditionalPlugin( + "resolve-as-module", + { directory: false, request: "." }, + "single file module", + true, + "undescribed-raw-file", + ), + ); + } + plugins.push( + new DirectoryExistsPlugin( + "resolve-as-module", + "undescribed-resolve-in-package", + ), + ); + + // undescribed-resolve-in-package + plugins.push( + new DescriptionFilePlugin( + "undescribed-resolve-in-package", + descriptionFiles, + false, + "resolve-in-package", + ), + ); + plugins.push( + new NextPlugin( + "after-undescribed-resolve-in-package", + "resolve-in-package", + ), + ); + + // resolve-in-package + for (const exportsField of exportsFields) { + plugins.push( + new ExportsFieldPlugin( + "resolve-in-package", + conditionNames, + exportsField, + "relative", + ), + ); + } + plugins.push( + new NextPlugin("resolve-in-package", "resolve-in-existing-directory"), + ); + + // resolve-in-existing-directory + plugins.push( + new JoinRequestPlugin("resolve-in-existing-directory", "relative"), + ); + + // relative + plugins.push( + new DescriptionFilePlugin( + "relative", + descriptionFiles, + true, + "described-relative", + ), + ); + plugins.push(new NextPlugin("after-relative", "described-relative")); + + // described-relative + if (resolveToContext) { + plugins.push(new NextPlugin("described-relative", "directory")); + } else { + plugins.push( + new ConditionalPlugin( + "described-relative", + { directory: false }, + null, + true, + "raw-file", + ), + ); + plugins.push( + new ConditionalPlugin( + "described-relative", + { fullySpecified: false }, + "as directory", + true, + "directory", + ), + ); + } + + // directory + plugins.push( + new DirectoryExistsPlugin("directory", "undescribed-existing-directory"), + ); + + if (resolveToContext) { + // undescribed-existing-directory + plugins.push(new NextPlugin("undescribed-existing-directory", "resolved")); + } else { + // undescribed-existing-directory + plugins.push( + new DescriptionFilePlugin( + "undescribed-existing-directory", + descriptionFiles, + false, + "existing-directory", + ), + ); + for (const item of mainFiles) { + plugins.push( + new UseFilePlugin( + "undescribed-existing-directory", + item, + "undescribed-raw-file", + ), + ); + } + + // described-existing-directory + for (const item of mainFields) { + plugins.push( + new MainFieldPlugin( + "existing-directory", + item, + "resolve-in-existing-directory", + ), + ); + } + for (const item of mainFiles) { + plugins.push( + new UseFilePlugin("existing-directory", item, "undescribed-raw-file"), + ); + } + + // undescribed-raw-file + plugins.push( + new DescriptionFilePlugin( + "undescribed-raw-file", + descriptionFiles, + true, + "raw-file", + ), + ); + plugins.push(new NextPlugin("after-undescribed-raw-file", "raw-file")); + + // raw-file + plugins.push( + new ConditionalPlugin( + "raw-file", + { fullySpecified: true }, + null, + false, + "file", + ), + ); + if (!enforceExtension) { + plugins.push(new TryNextPlugin("raw-file", "no extension", "file")); + } + for (const item of extensions) { + plugins.push(new AppendPlugin("raw-file", item, "file")); + } + + // file + if (alias.length > 0) { + plugins.push(new AliasPlugin("file", alias, "internal-resolve")); + } + for (const item of aliasFields) { + plugins.push(new AliasFieldPlugin("file", item, "internal-resolve")); + } + plugins.push(new NextPlugin("file", "final-file")); + + // final-file + plugins.push(new FileExistsPlugin("final-file", "existing-file")); + + // existing-file + if (symlinks) { + plugins.push(new SymlinkPlugin("existing-file", "existing-file")); + } + plugins.push(new NextPlugin("existing-file", "resolved")); + } + + const { resolved } = + /** @type {KnownHooks & EnsuredHooks} */ + (resolver.hooks); + + // resolved + if (restrictions.size > 0) { + plugins.push(new RestrictionsPlugin(resolved, restrictions)); + } + + plugins.push(new ResultPlugin(resolved)); + + // // RESOLVER //// + + for (const plugin of plugins) { + if (typeof plugin === "function") { + /** @type {(this: Resolver, resolver: Resolver) => void} */ + (plugin).call(resolver, resolver); + } else if (plugin) { + plugin.apply(resolver); + } + } + + return resolver; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/RestrictionsPlugin.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/RestrictionsPlugin.js new file mode 100644 index 0000000000000000000000000000000000000000..6faaa26bc33601d3d0458c27ae58c5f75f29bb50 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/RestrictionsPlugin.js @@ -0,0 +1,70 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Ivan Kopeykin @vankop +*/ + +"use strict"; + +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ + +const slashCode = "/".charCodeAt(0); +const backslashCode = "\\".charCodeAt(0); + +/** + * @param {string} path path + * @param {string} parent parent path + * @returns {boolean} true, if path is inside of parent + */ +const isInside = (path, parent) => { + if (!path.startsWith(parent)) return false; + if (path.length === parent.length) return true; + const charCode = path.charCodeAt(parent.length); + return charCode === slashCode || charCode === backslashCode; +}; + +module.exports = class RestrictionsPlugin { + /** + * @param {string | ResolveStepHook} source source + * @param {Set} restrictions restrictions + */ + constructor(source, restrictions) { + this.source = source; + this.restrictions = restrictions; + } + + /** + * @param {Resolver} resolver the resolver + * @returns {void} + */ + apply(resolver) { + resolver + .getHook(this.source) + .tapAsync("RestrictionsPlugin", (request, resolveContext, callback) => { + if (typeof request.path === "string") { + const { path } = request; + for (const rule of this.restrictions) { + if (typeof rule === "string") { + if (!isInside(path, rule)) { + if (resolveContext.log) { + resolveContext.log( + `${path} is not inside of the restriction ${rule}`, + ); + } + return callback(null, null); + } + } else if (!rule.test(path)) { + if (resolveContext.log) { + resolveContext.log( + `${path} doesn't match the restriction ${rule}`, + ); + } + return callback(null, null); + } + } + } + + callback(); + }); + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ResultPlugin.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ResultPlugin.js new file mode 100644 index 0000000000000000000000000000000000000000..57dbdddc3ad43fdb70c81da5365fe96cab4b6318 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/ResultPlugin.js @@ -0,0 +1,43 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ + +module.exports = class ResultPlugin { + /** + * @param {ResolveStepHook} source source + */ + constructor(source) { + this.source = source; + } + + /** + * @param {Resolver} resolver the resolver + * @returns {void} + */ + apply(resolver) { + this.source.tapAsync( + "ResultPlugin", + (request, resolverContext, callback) => { + const obj = { ...request }; + if (resolverContext.log) { + resolverContext.log(`reporting result ${obj.path}`); + } + resolver.hooks.result.callAsync(obj, resolverContext, (err) => { + if (err) return callback(err); + if (typeof resolverContext.yield === "function") { + resolverContext.yield(obj); + callback(null, null); + } else { + callback(null, obj); + } + }); + }, + ); + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/RootsPlugin.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/RootsPlugin.js new file mode 100644 index 0000000000000000000000000000000000000000..ce5b3147e5484b2b8bc780596d9858b685743527 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/RootsPlugin.js @@ -0,0 +1,69 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Ivan Kopeykin @vankop +*/ + +"use strict"; + +const forEachBail = require("./forEachBail"); + +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ +/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ + +class RootsPlugin { + /** + * @param {string | ResolveStepHook} source source hook + * @param {Set} roots roots + * @param {string | ResolveStepHook} target target hook + */ + constructor(source, roots, target) { + this.roots = [...roots]; + this.source = source; + this.target = target; + } + + /** + * @param {Resolver} resolver the resolver + * @returns {void} + */ + apply(resolver) { + const target = resolver.ensureHook(this.target); + + resolver + .getHook(this.source) + .tapAsync("RootsPlugin", (request, resolveContext, callback) => { + const req = request.request; + if (!req) return callback(); + if (!req.startsWith("/")) return callback(); + + forEachBail( + this.roots, + /** + * @param {string} root root + * @param {(err?: null|Error, result?: null|ResolveRequest) => void} callback callback + * @returns {void} + */ + (root, callback) => { + const path = resolver.join(root, req.slice(1)); + /** @type {ResolveRequest} */ + const obj = { + ...request, + path, + relativePath: request.relativePath && path, + }; + resolver.doResolve( + target, + obj, + `root path ${root}`, + resolveContext, + callback, + ); + }, + callback, + ); + }); + } +} + +module.exports = RootsPlugin; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/SelfReferencePlugin.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/SelfReferencePlugin.js new file mode 100644 index 0000000000000000000000000000000000000000..af8e5b23eb3285edf2d9817391864000bf1a4a62 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/SelfReferencePlugin.js @@ -0,0 +1,82 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const DescriptionFileUtils = require("./DescriptionFileUtils"); + +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").JsonObject} JsonObject */ +/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ +/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ + +const slashCode = "/".charCodeAt(0); + +module.exports = class SelfReferencePlugin { + /** + * @param {string | ResolveStepHook} source source + * @param {string | string[]} fieldNamePath name path + * @param {string | ResolveStepHook} target target + */ + constructor(source, fieldNamePath, target) { + this.source = source; + this.target = target; + this.fieldName = fieldNamePath; + } + + /** + * @param {Resolver} resolver the resolver + * @returns {void} + */ + apply(resolver) { + const target = resolver.ensureHook(this.target); + resolver + .getHook(this.source) + .tapAsync("SelfReferencePlugin", (request, resolveContext, callback) => { + if (!request.descriptionFilePath) return callback(); + + const req = request.request; + if (!req) return callback(); + + // Feature is only enabled when an exports field is present + const exportsField = DescriptionFileUtils.getField( + /** @type {JsonObject} */ (request.descriptionFileData), + this.fieldName, + ); + if (!exportsField) return callback(); + + const name = DescriptionFileUtils.getField( + /** @type {JsonObject} */ (request.descriptionFileData), + "name", + ); + if (typeof name !== "string") return callback(); + + if ( + req.startsWith(name) && + (req.length === name.length || + req.charCodeAt(name.length) === slashCode) + ) { + const remainingRequest = `.${req.slice(name.length)}`; + /** @type {ResolveRequest} */ + const obj = { + ...request, + request: remainingRequest, + path: /** @type {string} */ (request.descriptionFileRoot), + relativePath: ".", + }; + + resolver.doResolve( + target, + obj, + "self reference", + resolveContext, + callback, + ); + } else { + return callback(); + } + }); + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/SymlinkPlugin.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/SymlinkPlugin.js new file mode 100644 index 0000000000000000000000000000000000000000..939d40a7724cfeadb2e02afc7ebb4a5a84cacf02 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/SymlinkPlugin.js @@ -0,0 +1,101 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const forEachBail = require("./forEachBail"); +const getPaths = require("./getPaths"); +const { PathType, getType } = require("./util/path"); + +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ +/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ + +module.exports = class SymlinkPlugin { + /** + * @param {string | ResolveStepHook} source source + * @param {string | ResolveStepHook} target target + */ + constructor(source, target) { + this.source = source; + this.target = target; + } + + /** + * @param {Resolver} resolver the resolver + * @returns {void} + */ + apply(resolver) { + const target = resolver.ensureHook(this.target); + const fs = resolver.fileSystem; + resolver + .getHook(this.source) + .tapAsync("SymlinkPlugin", (request, resolveContext, callback) => { + if (request.ignoreSymlinks) return callback(); + const pathsResult = getPaths(/** @type {string} */ (request.path)); + const pathSegments = pathsResult.segments; + const { paths } = pathsResult; + + let containsSymlink = false; + let idx = -1; + forEachBail( + paths, + /** + * @param {string} path path + * @param {(err?: null|Error, result?: null|number) => void} callback callback + * @returns {void} + */ + (path, callback) => { + idx++; + if (resolveContext.fileDependencies) { + resolveContext.fileDependencies.add(path); + } + fs.readlink(path, (err, result) => { + if (!err && result) { + pathSegments[idx] = /** @type {string} */ (result); + containsSymlink = true; + // Shortcut when absolute symlink found + const resultType = getType(result.toString()); + if ( + resultType === PathType.AbsoluteWin || + resultType === PathType.AbsolutePosix + ) { + return callback(null, idx); + } + } + callback(); + }); + }, + /** + * @param {(null | Error)=} err error + * @param {(null|number)=} idx result + * @returns {void} + */ + (err, idx) => { + if (!containsSymlink) return callback(); + const resultSegments = + typeof idx === "number" + ? pathSegments.slice(0, idx + 1) + : [...pathSegments]; + const result = resultSegments.reduceRight((a, b) => + resolver.join(a, b), + ); + /** @type {ResolveRequest} */ + const obj = { + ...request, + path: result, + }; + resolver.doResolve( + target, + obj, + `resolved symlink to ${result}`, + resolveContext, + callback, + ); + }, + ); + }); + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/SyncAsyncFileSystemDecorator.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/SyncAsyncFileSystemDecorator.js new file mode 100644 index 0000000000000000000000000000000000000000..c850cdaf4df9698e7cc627b4eabb1d52b9726243 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/SyncAsyncFileSystemDecorator.js @@ -0,0 +1,258 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("./Resolver").FileSystem} FileSystem */ +/** @typedef {import("./Resolver").StringCallback} StringCallback */ +/** @typedef {import("./Resolver").SyncFileSystem} SyncFileSystem */ + +// eslint-disable-next-line jsdoc/no-restricted-syntax +/** @typedef {Function} SyncOrAsyncFunction */ +// eslint-disable-next-line jsdoc/no-restricted-syntax +/** @typedef {any} ResultOfSyncOrAsyncFunction */ + +/** + * @param {SyncFileSystem} fs file system implementation + * @constructor + */ +function SyncAsyncFileSystemDecorator(fs) { + this.fs = fs; + + this.lstat = undefined; + this.lstatSync = undefined; + const { lstatSync } = fs; + if (lstatSync) { + this.lstat = + /** @type {FileSystem["lstat"]} */ + ( + (arg, options, callback) => { + let result; + try { + result = /** @type {SyncOrAsyncFunction | undefined} */ (callback) + ? lstatSync.call(fs, arg, options) + : lstatSync.call(fs, arg); + } catch (err) { + return (callback || options)( + /** @type {NodeJS.ErrnoException | null} */ + (err), + ); + } + + (callback || options)( + null, + /** @type {ResultOfSyncOrAsyncFunction} */ + (result), + ); + } + ); + this.lstatSync = + /** @type {SyncFileSystem["lstatSync"]} */ + ((arg, options) => lstatSync.call(fs, arg, options)); + } + + this.stat = + /** @type {FileSystem["stat"]} */ + ( + (arg, options, callback) => { + let result; + try { + result = /** @type {SyncOrAsyncFunction | undefined} */ (callback) + ? fs.statSync(arg, options) + : fs.statSync(arg); + } catch (err) { + return (callback || options)( + /** @type {NodeJS.ErrnoException | null} */ + (err), + ); + } + + (callback || options)( + null, + /** @type {ResultOfSyncOrAsyncFunction} */ + (result), + ); + } + ); + this.statSync = + /** @type {SyncFileSystem["statSync"]} */ + ((arg, options) => fs.statSync(arg, options)); + + this.readdir = + /** @type {FileSystem["readdir"]} */ + ( + (arg, options, callback) => { + let result; + try { + result = /** @type {SyncOrAsyncFunction | undefined} */ (callback) + ? fs.readdirSync( + arg, + /** @type {Exclude[1], (err: NodeJS.ErrnoException | null, files: string[]) => void>} */ + (options), + ) + : fs.readdirSync(arg); + } catch (err) { + return (callback || options)( + /** @type {NodeJS.ErrnoException | null} */ + (err), + [], + ); + } + + (callback || options)( + null, + /** @type {ResultOfSyncOrAsyncFunction} */ + (result), + ); + } + ); + this.readdirSync = + /** @type {SyncFileSystem["readdirSync"]} */ + ( + (arg, options) => + fs.readdirSync( + arg, + /** @type {Parameters[1]} */ (options), + ) + ); + + this.readFile = + /** @type {FileSystem["readFile"]} */ + ( + (arg, options, callback) => { + let result; + try { + result = /** @type {SyncOrAsyncFunction | undefined} */ (callback) + ? fs.readFileSync(arg, options) + : fs.readFileSync(arg); + } catch (err) { + return (callback || options)( + /** @type {NodeJS.ErrnoException | null} */ + (err), + ); + } + + (callback || options)( + null, + /** @type {ResultOfSyncOrAsyncFunction} */ + (result), + ); + } + ); + this.readFileSync = + /** @type {SyncFileSystem["readFileSync"]} */ + ((arg, options) => fs.readFileSync(arg, options)); + + this.readlink = + /** @type {FileSystem["readlink"]} */ + ( + (arg, options, callback) => { + let result; + try { + result = /** @type {SyncOrAsyncFunction | undefined} */ (callback) + ? fs.readlinkSync( + arg, + /** @type {Exclude[1], StringCallback>} */ + (options), + ) + : fs.readlinkSync(arg); + } catch (err) { + return (callback || options)( + /** @type {NodeJS.ErrnoException | null} */ + (err), + ); + } + + (callback || options)( + null, + /** @type {ResultOfSyncOrAsyncFunction} */ + (result), + ); + } + ); + this.readlinkSync = + /** @type {SyncFileSystem["readlinkSync"]} */ + ( + (arg, options) => + fs.readlinkSync( + arg, + /** @type {Parameters[1]} */ ( + options + ), + ) + ); + + this.readJson = undefined; + this.readJsonSync = undefined; + const { readJsonSync } = fs; + if (readJsonSync) { + this.readJson = + /** @type {FileSystem["readJson"]} */ + ( + (arg, callback) => { + let result; + try { + result = readJsonSync.call(fs, arg); + } catch (err) { + return callback( + /** @type {NodeJS.ErrnoException | Error | null} */ (err), + ); + } + + callback(null, result); + } + ); + this.readJsonSync = + /** @type {SyncFileSystem["readJsonSync"]} */ + ((arg) => readJsonSync.call(fs, arg)); + } + + this.realpath = undefined; + this.realpathSync = undefined; + const { realpathSync } = fs; + if (realpathSync) { + this.realpath = + /** @type {FileSystem["realpath"]} */ + ( + (arg, options, callback) => { + let result; + try { + result = /** @type {SyncOrAsyncFunction | undefined} */ (callback) + ? realpathSync.call( + fs, + arg, + /** @type {Exclude>[1], StringCallback>} */ + (options), + ) + : realpathSync.call(fs, arg); + } catch (err) { + return (callback || options)( + /** @type {NodeJS.ErrnoException | null} */ + (err), + ); + } + + (callback || options)( + null, + /** @type {ResultOfSyncOrAsyncFunction} */ + (result), + ); + } + ); + this.realpathSync = + /** @type {SyncFileSystem["realpathSync"]} */ + ( + (arg, options) => + realpathSync.call( + fs, + arg, + /** @type {Parameters>[1]} */ + (options), + ) + ); + } +} + +module.exports = SyncAsyncFileSystemDecorator; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/TryNextPlugin.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/TryNextPlugin.js new file mode 100644 index 0000000000000000000000000000000000000000..4b467871eba72d030132b5b1a081735fe80c3f2a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/TryNextPlugin.js @@ -0,0 +1,41 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ + +module.exports = class TryNextPlugin { + /** + * @param {string | ResolveStepHook} source source + * @param {string} message message + * @param {string | ResolveStepHook} target target + */ + constructor(source, message, target) { + this.source = source; + this.message = message; + this.target = target; + } + + /** + * @param {Resolver} resolver the resolver + * @returns {void} + */ + apply(resolver) { + const target = resolver.ensureHook(this.target); + resolver + .getHook(this.source) + .tapAsync("TryNextPlugin", (request, resolveContext, callback) => { + resolver.doResolve( + target, + request, + this.message, + resolveContext, + callback, + ); + }); + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/UnsafeCachePlugin.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/UnsafeCachePlugin.js new file mode 100644 index 0000000000000000000000000000000000000000..56c6217173be51a55e1f1d0c5bb3dfa7d8a020c6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/UnsafeCachePlugin.js @@ -0,0 +1,114 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ +/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ +/** @typedef {import("./Resolver").ResolveContextYield} ResolveContextYield */ +/** @typedef {{ [k: string]: undefined | ResolveRequest | ResolveRequest[] }} Cache */ + +/** + * @param {string} type type of cache + * @param {ResolveRequest} request request + * @param {boolean} withContext cache with context? + * @returns {string} cache id + */ +function getCacheId(type, request, withContext) { + return JSON.stringify({ + type, + context: withContext ? request.context : "", + path: request.path, + query: request.query, + fragment: request.fragment, + request: request.request, + }); +} + +module.exports = class UnsafeCachePlugin { + /** + * @param {string | ResolveStepHook} source source + * @param {(request: ResolveRequest) => boolean} filterPredicate filterPredicate + * @param {Cache} cache cache + * @param {boolean} withContext withContext + * @param {string | ResolveStepHook} target target + */ + constructor(source, filterPredicate, cache, withContext, target) { + this.source = source; + this.filterPredicate = filterPredicate; + this.withContext = withContext; + this.cache = cache; + this.target = target; + } + + /** + * @param {Resolver} resolver the resolver + * @returns {void} + */ + apply(resolver) { + const target = resolver.ensureHook(this.target); + resolver + .getHook(this.source) + .tapAsync("UnsafeCachePlugin", (request, resolveContext, callback) => { + if (!this.filterPredicate(request)) return callback(); + const isYield = typeof resolveContext.yield === "function"; + const cacheId = getCacheId( + isYield ? "yield" : "default", + request, + this.withContext, + ); + const cacheEntry = this.cache[cacheId]; + if (cacheEntry) { + if (isYield) { + const yield_ = + /** @type {ResolveContextYield} */ + (resolveContext.yield); + if (Array.isArray(cacheEntry)) { + for (const result of cacheEntry) yield_(result); + } else { + yield_(cacheEntry); + } + return callback(null, null); + } + return callback(null, /** @type {ResolveRequest} */ (cacheEntry)); + } + + /** @type {ResolveContextYield | undefined} */ + let yieldFn; + /** @type {ResolveContextYield | undefined} */ + let yield_; + /** @type {ResolveRequest[]} */ + const yieldResult = []; + if (isYield) { + yieldFn = resolveContext.yield; + yield_ = (result) => { + yieldResult.push(result); + }; + } + + resolver.doResolve( + target, + request, + null, + yield_ ? { ...resolveContext, yield: yield_ } : resolveContext, + (err, result) => { + if (err) return callback(err); + if (isYield) { + if (result) yieldResult.push(result); + for (const result of yieldResult) { + /** @type {ResolveContextYield} */ + (yieldFn)(result); + } + this.cache[cacheId] = yieldResult; + return callback(null, null); + } + if (result) return callback(null, (this.cache[cacheId] = result)); + callback(); + }, + ); + }); + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/UseFilePlugin.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/UseFilePlugin.js new file mode 100644 index 0000000000000000000000000000000000000000..f81c27f5fbbb3ff0d7ddbf7a88d737a3b711b584 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/UseFilePlugin.js @@ -0,0 +1,55 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ +/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ + +module.exports = class UseFilePlugin { + /** + * @param {string | ResolveStepHook} source source + * @param {string} filename filename + * @param {string | ResolveStepHook} target target + */ + constructor(source, filename, target) { + this.source = source; + this.filename = filename; + this.target = target; + } + + /** + * @param {Resolver} resolver the resolver + * @returns {void} + */ + apply(resolver) { + const target = resolver.ensureHook(this.target); + resolver + .getHook(this.source) + .tapAsync("UseFilePlugin", (request, resolveContext, callback) => { + const filePath = resolver.join( + /** @type {string} */ (request.path), + this.filename, + ); + + /** @type {ResolveRequest} */ + const obj = { + ...request, + path: filePath, + relativePath: + request.relativePath && + resolver.join(request.relativePath, this.filename), + }; + resolver.doResolve( + target, + obj, + `using path: ${filePath}`, + resolveContext, + callback, + ); + }); + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/createInnerContext.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/createInnerContext.js new file mode 100644 index 0000000000000000000000000000000000000000..2ce53f58d8183d23c1d974fabf74b71477bed9dd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/createInnerContext.js @@ -0,0 +1,46 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("./Resolver").ResolveContext} ResolveContext */ + +/** + * @param {ResolveContext} options options for inner context + * @param {null|string} message message to log + * @returns {ResolveContext} inner context + */ +module.exports = function createInnerContext(options, message) { + let messageReported = false; + let innerLog; + if (options.log) { + if (message) { + /** + * @param {string} msg message + */ + innerLog = (msg) => { + if (!messageReported) { + /** @type {((str: string) => void)} */ + (options.log)(message); + messageReported = true; + } + + /** @type {((str: string) => void)} */ + (options.log)(` ${msg}`); + }; + } else { + innerLog = options.log; + } + } + + return { + log: innerLog, + yield: options.yield, + fileDependencies: options.fileDependencies, + contextDependencies: options.contextDependencies, + missingDependencies: options.missingDependencies, + stack: options.stack, + }; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/forEachBail.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/forEachBail.js new file mode 100644 index 0000000000000000000000000000000000000000..6dc4d1eecdbdf8c3e71249663b205440f0998437 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/forEachBail.js @@ -0,0 +1,50 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ + +/** + * @template T + * @template Z + * @callback Iterator + * @param {T} item item + * @param {(err?: null|Error, result?: null|Z) => void} callback callback + * @param {number} i index + * @returns {void} + */ + +/** + * @template T + * @template Z + * @param {T[]} array array + * @param {Iterator} iterator iterator + * @param {(err?: null|Error, result?: null|Z, i?: number) => void} callback callback after all items are iterated + * @returns {void} + */ +module.exports = function forEachBail(array, iterator, callback) { + if (array.length === 0) return callback(); + + let i = 0; + const next = () => { + /** @type {boolean|undefined} */ + let loop; + iterator( + array[i++], + (err, result) => { + if (err || result !== undefined || i >= array.length) { + return callback(err, result, i); + } + if (loop === false) while (next()); + loop = true; + }, + i, + ); + if (!loop) loop = false; + return loop; + }; + while (next()); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/getInnerRequest.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/getInnerRequest.js new file mode 100644 index 0000000000000000000000000000000000000000..58b1474c833fce98ec6f45b56a88f7be2b812c69 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/getInnerRequest.js @@ -0,0 +1,39 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ + +/** + * @param {Resolver} resolver resolver + * @param {ResolveRequest} request string + * @returns {string} inner request + */ +module.exports = function getInnerRequest(resolver, request) { + if ( + typeof request.__innerRequest === "string" && + request.__innerRequest_request === request.request && + request.__innerRequest_relativePath === request.relativePath + ) { + return request.__innerRequest; + } + /** @type {string|undefined} */ + let innerRequest; + if (request.request) { + innerRequest = request.request; + if (/^\.\.?(?:\/|$)/.test(innerRequest) && request.relativePath) { + innerRequest = resolver.join(request.relativePath, innerRequest); + } + } else { + innerRequest = request.relativePath; + } + // eslint-disable-next-line camelcase + request.__innerRequest_request = request.request; + // eslint-disable-next-line camelcase + request.__innerRequest_relativePath = request.relativePath; + return (request.__innerRequest = /** @type {string} */ (innerRequest)); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/getPaths.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/getPaths.js new file mode 100644 index 0000000000000000000000000000000000000000..cf0c9ca1a93960073952f50aecb293b3c5fe9bfd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/getPaths.js @@ -0,0 +1,45 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** + * @param {string} path path + * @returns {{paths: string[], segments: string[]}}} paths and segments + */ +module.exports = function getPaths(path) { + if (path === "/") return { paths: ["/"], segments: [""] }; + const parts = path.split(/(.*?[\\/]+)/); + const paths = [path]; + const segments = [parts[parts.length - 1]]; + let part = parts[parts.length - 1]; + path = path.slice(0, Math.max(0, path.length - part.length - 1)); + for (let i = parts.length - 2; i > 2; i -= 2) { + paths.push(path); + part = parts[i]; + path = path.slice(0, Math.max(0, path.length - part.length)) || "/"; + segments.push(part.slice(0, -1)); + } + [, part] = parts; + segments.push(part); + paths.push(part); + return { + paths, + segments, + }; +}; + +/** + * @param {string} path path + * @returns {string|null} basename or null + */ +module.exports.basename = function basename(path) { + const i = path.lastIndexOf("/"); + const j = path.lastIndexOf("\\"); + const resolvedPath = i < 0 ? j : j < 0 ? i : i < j ? j : i; + if (resolvedPath < 0) return null; + const basename = path.slice(resolvedPath + 1); + return basename; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/index.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/index.js new file mode 100644 index 0000000000000000000000000000000000000000..9b10143056d42805d63ccac2b95eea21913327cb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/index.js @@ -0,0 +1,225 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const memoize = require("./util/memoize"); + +/** @typedef {import("./CachedInputFileSystem").BaseFileSystem} BaseFileSystem */ +/** @typedef {import("./PnpPlugin").PnpApiImpl} PnpApi */ +/** @typedef {import("./Resolver")} Resolver */ +/** @typedef {import("./Resolver").FileSystem} FileSystem */ +/** @typedef {import("./Resolver").ResolveCallback} ResolveCallback */ +/** @typedef {import("./Resolver").ResolveContext} ResolveContext */ +/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ +/** @typedef {import("./Resolver").SyncFileSystem} SyncFileSystem */ +/** @typedef {import("./ResolverFactory").Plugin} Plugin */ +/** @typedef {import("./ResolverFactory").UserResolveOptions} ResolveOptions */ + +/** + * @typedef {{ + * (context: object, path: string, request: string, resolveContext: ResolveContext, callback: ResolveCallback): void; + * (context: object, path: string, request: string, callback: ResolveCallback): void; + * (path: string, request: string, resolveContext: ResolveContext, callback: ResolveCallback): void; + * (path: string, request: string, callback: ResolveCallback): void; + * }} ResolveFunctionAsync + */ + +/** + * @typedef {{ + * (context: object, path: string, request: string): string | false; + * (path: string, request: string): string | false; + * }} ResolveFunction + */ + +const getCachedFileSystem = memoize(() => require("./CachedInputFileSystem")); + +const getNodeFileSystem = memoize(() => { + const fs = require("graceful-fs"); + + const CachedInputFileSystem = getCachedFileSystem(); + + return new CachedInputFileSystem(fs, 4000); +}); +const getNodeContext = memoize(() => ({ + environments: ["node+es3+es5+process+native"], +})); + +const getResolverFactory = memoize(() => require("./ResolverFactory")); + +const getAsyncResolver = memoize(() => + getResolverFactory().createResolver({ + conditionNames: ["node"], + extensions: [".js", ".json", ".node"], + fileSystem: getNodeFileSystem(), + }), +); + +/** + * @type {ResolveFunctionAsync} + */ +const resolve = + /** + * @param {object | string} context context + * @param {string} path path + * @param {string | ResolveContext | ResolveCallback} request request + * @param {ResolveContext | ResolveCallback=} resolveContext resolve context + * @param {ResolveCallback=} callback callback + */ + (context, path, request, resolveContext, callback) => { + if (typeof context === "string") { + callback = /** @type {ResolveCallback} */ (resolveContext); + resolveContext = /** @type {ResolveContext} */ (request); + request = path; + path = context; + context = getNodeContext(); + } + if (typeof callback !== "function") { + callback = /** @type {ResolveCallback} */ (resolveContext); + } + getAsyncResolver().resolve( + context, + path, + /** @type {string} */ (request), + /** @type {ResolveContext} */ (resolveContext), + /** @type {ResolveCallback} */ (callback), + ); + }; + +const getSyncResolver = memoize(() => + getResolverFactory().createResolver({ + conditionNames: ["node"], + extensions: [".js", ".json", ".node"], + useSyncFileSystemCalls: true, + fileSystem: getNodeFileSystem(), + }), +); + +/** + * @type {ResolveFunction} + */ +const resolveSync = + /** + * @param {object|string} context context + * @param {string} path path + * @param {string=} request request + * @returns {string | false} result + */ + (context, path, request) => { + if (typeof context === "string") { + request = path; + path = context; + context = getNodeContext(); + } + return getSyncResolver().resolveSync( + context, + path, + /** @type {string} */ (request), + ); + }; + +/** @typedef {Omit & Partial>} ResolveOptionsOptionalFS */ + +/** + * @param {ResolveOptionsOptionalFS} options Resolver options + * @returns {ResolveFunctionAsync} Resolver function + */ +function create(options) { + const resolver = getResolverFactory().createResolver({ + fileSystem: getNodeFileSystem(), + ...options, + }); + /** + * @param {object|string} context Custom context + * @param {string} path Base path + * @param {string|ResolveContext|ResolveCallback} request String to resolve + * @param {ResolveContext|ResolveCallback=} resolveContext Resolve context + * @param {ResolveCallback=} callback Result callback + */ + return function create(context, path, request, resolveContext, callback) { + if (typeof context === "string") { + callback = /** @type {ResolveCallback} */ (resolveContext); + resolveContext = /** @type {ResolveContext} */ (request); + request = path; + path = context; + context = getNodeContext(); + } + if (typeof callback !== "function") { + callback = /** @type {ResolveCallback} */ (resolveContext); + } + resolver.resolve( + context, + path, + /** @type {string} */ (request), + /** @type {ResolveContext} */ (resolveContext), + callback, + ); + }; +} + +/** + * @param {ResolveOptionsOptionalFS} options Resolver options + * @returns {ResolveFunction} Resolver function + */ +function createSync(options) { + const resolver = getResolverFactory().createResolver({ + useSyncFileSystemCalls: true, + fileSystem: getNodeFileSystem(), + ...options, + }); + /** + * @param {object | string} context custom context + * @param {string} path base path + * @param {string=} request request to resolve + * @returns {string | false} Resolved path or false + */ + return function createSync(context, path, request) { + if (typeof context === "string") { + request = path; + path = context; + context = getNodeContext(); + } + return resolver.resolveSync(context, path, /** @type {string} */ (request)); + }; +} + +/** + * @template A + * @template B + * @param {A} obj input a + * @param {B} exports input b + * @returns {A & B} merged + */ +const mergeExports = (obj, exports) => { + const descriptors = Object.getOwnPropertyDescriptors(exports); + Object.defineProperties(obj, descriptors); + return /** @type {A & B} */ (Object.freeze(obj)); +}; + +module.exports = mergeExports(resolve, { + get sync() { + return resolveSync; + }, + create: mergeExports(create, { + get sync() { + return createSync; + }, + }), + get ResolverFactory() { + return getResolverFactory(); + }, + get CachedInputFileSystem() { + return getCachedFileSystem(); + }, + get CloneBasenamePlugin() { + return require("./CloneBasenamePlugin"); + }, + get LogInfoPlugin() { + return require("./LogInfoPlugin"); + }, + get forEachBail() { + return require("./forEachBail"); + }, +}); diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/util/entrypoints.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/util/entrypoints.js new file mode 100644 index 0000000000000000000000000000000000000000..55f018c1325a0f23cdcb2c0f5d6f7e6a6185ff04 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/util/entrypoints.js @@ -0,0 +1,574 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Ivan Kopeykin @vankop +*/ + +"use strict"; + +const { parseIdentifier } = require("./identifier"); + +/** @typedef {string|(string|ConditionalMapping)[]} DirectMapping */ +/** @typedef {{[k: string]: MappingValue}} ConditionalMapping */ +/** @typedef {ConditionalMapping|DirectMapping|null} MappingValue */ +/** @typedef {Record|ConditionalMapping|DirectMapping} ExportsField */ +/** @typedef {Record} ImportsField */ + +/** + * Processing exports/imports field + * @callback FieldProcessor + * @param {string} request request + * @param {Set} conditionNames condition names + * @returns {[string[], string | null]} resolved paths with used field + */ + +/* +Example exports field: +{ + ".": "./main.js", + "./feature": { + "browser": "./feature-browser.js", + "default": "./feature.js" + } +} +Terminology: + +Enhanced-resolve name keys ("." and "./feature") as exports field keys. + +If value is string or string[], mapping is called as a direct mapping +and value called as a direct export. + +If value is key-value object, mapping is called as a conditional mapping +and value called as a conditional export. + +Key in conditional mapping is called condition name. + +Conditional mapping nested in another conditional mapping is called nested mapping. + +---------- + +Example imports field: +{ + "#a": "./main.js", + "#moment": { + "browser": "./moment/index.js", + "default": "moment" + }, + "#moment/": { + "browser": "./moment/", + "default": "moment/" + } +} +Terminology: + +Enhanced-resolve name keys ("#a" and "#moment/", "#moment") as imports field keys. + +If value is string or string[], mapping is called as a direct mapping +and value called as a direct export. + +If value is key-value object, mapping is called as a conditional mapping +and value called as a conditional export. + +Key in conditional mapping is called condition name. + +Conditional mapping nested in another conditional mapping is called nested mapping. + +*/ + +const slashCode = "/".charCodeAt(0); +const dotCode = ".".charCodeAt(0); +const hashCode = "#".charCodeAt(0); +const patternRegEx = /\*/g; + +/** + * @param {string} a first string + * @param {string} b second string + * @returns {number} compare result + */ +function patternKeyCompare(a, b) { + const aPatternIndex = a.indexOf("*"); + const bPatternIndex = b.indexOf("*"); + const baseLenA = aPatternIndex === -1 ? a.length : aPatternIndex + 1; + const baseLenB = bPatternIndex === -1 ? b.length : bPatternIndex + 1; + + if (baseLenA > baseLenB) return -1; + if (baseLenB > baseLenA) return 1; + if (aPatternIndex === -1) return 1; + if (bPatternIndex === -1) return -1; + if (a.length > b.length) return -1; + if (b.length > a.length) return 1; + + return 0; +} + +/** + * Trying to match request to field + * @param {string} request request + * @param {ExportsField | ImportsField} field exports or import field + * @returns {[MappingValue, string, boolean, boolean, string]|null} match or null, number is negative and one less when it's a folder mapping, number is request.length + 1 for direct mappings + */ +function findMatch(request, field) { + if ( + Object.prototype.hasOwnProperty.call(field, request) && + !request.includes("*") && + !request.endsWith("/") + ) { + const target = /** @type {{[k: string]: MappingValue}} */ (field)[request]; + + return [target, "", false, false, request]; + } + + /** @type {string} */ + let bestMatch = ""; + /** @type {string|undefined} */ + let bestMatchSubpath; + + const keys = Object.getOwnPropertyNames(field); + + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const patternIndex = key.indexOf("*"); + + if (patternIndex !== -1 && request.startsWith(key.slice(0, patternIndex))) { + const patternTrailer = key.slice(patternIndex + 1); + + if ( + request.length >= key.length && + request.endsWith(patternTrailer) && + patternKeyCompare(bestMatch, key) === 1 && + key.lastIndexOf("*") === patternIndex + ) { + bestMatch = key; + bestMatchSubpath = request.slice( + patternIndex, + request.length - patternTrailer.length, + ); + } + } + // For legacy `./foo/` + else if ( + key[key.length - 1] === "/" && + request.startsWith(key) && + patternKeyCompare(bestMatch, key) === 1 + ) { + bestMatch = key; + bestMatchSubpath = request.slice(key.length); + } + } + + if (bestMatch === "") return null; + + const target = /** @type {{[k: string]: MappingValue}} */ (field)[bestMatch]; + const isSubpathMapping = bestMatch.endsWith("/"); + const isPattern = bestMatch.includes("*"); + + return [ + target, + /** @type {string} */ (bestMatchSubpath), + isSubpathMapping, + isPattern, + bestMatch, + ]; +} + +/** + * @param {ConditionalMapping | DirectMapping|null} mapping mapping + * @returns {boolean} is conditional mapping + */ +function isConditionalMapping(mapping) { + return ( + mapping !== null && typeof mapping === "object" && !Array.isArray(mapping) + ); +} + +/** + * @param {ConditionalMapping} conditionalMapping_ conditional mapping + * @param {Set} conditionNames condition names + * @returns {DirectMapping | null} direct mapping if found + */ +function conditionalMapping(conditionalMapping_, conditionNames) { + /** @type {[ConditionalMapping, string[], number][]} */ + const lookup = [[conditionalMapping_, Object.keys(conditionalMapping_), 0]]; + + loop: while (lookup.length > 0) { + const [mapping, conditions, j] = lookup[lookup.length - 1]; + + for (let i = j; i < conditions.length; i++) { + const condition = conditions[i]; + + if (condition === "default") { + const innerMapping = mapping[condition]; + // is nested + if (isConditionalMapping(innerMapping)) { + const conditionalMapping = /** @type {ConditionalMapping} */ ( + innerMapping + ); + lookup[lookup.length - 1][2] = i + 1; + lookup.push([conditionalMapping, Object.keys(conditionalMapping), 0]); + continue loop; + } + + return /** @type {DirectMapping} */ (innerMapping); + } + + if (conditionNames.has(condition)) { + const innerMapping = mapping[condition]; + // is nested + if (isConditionalMapping(innerMapping)) { + const conditionalMapping = /** @type {ConditionalMapping} */ ( + innerMapping + ); + lookup[lookup.length - 1][2] = i + 1; + lookup.push([conditionalMapping, Object.keys(conditionalMapping), 0]); + continue loop; + } + + return /** @type {DirectMapping} */ (innerMapping); + } + } + + lookup.pop(); + } + + return null; +} + +/** + * @param {string | undefined} remainingRequest remaining request when folder mapping, undefined for file mappings + * @param {boolean} isPattern true, if mapping is a pattern (contains "*") + * @param {boolean} isSubpathMapping true, for subpath mappings + * @param {string} mappingTarget direct export + * @param {(d: string, f: boolean) => void} assert asserting direct value + * @returns {string} mapping result + */ +function targetMapping( + remainingRequest, + isPattern, + isSubpathMapping, + mappingTarget, + assert, +) { + if (remainingRequest === undefined) { + assert(mappingTarget, false); + + return mappingTarget; + } + + if (isSubpathMapping) { + assert(mappingTarget, true); + + return mappingTarget + remainingRequest; + } + + assert(mappingTarget, false); + + let result = mappingTarget; + + if (isPattern) { + result = result.replace( + patternRegEx, + remainingRequest.replace(/\$/g, "$$"), + ); + } + + return result; +} + +/** + * @param {string|undefined} remainingRequest remaining request when folder mapping, undefined for file mappings + * @param {boolean} isPattern true, if mapping is a pattern (contains "*") + * @param {boolean} isSubpathMapping true, for subpath mappings + * @param {DirectMapping|null} mappingTarget direct export + * @param {Set} conditionNames condition names + * @param {(d: string, f: boolean) => void} assert asserting direct value + * @returns {string[]} mapping result + */ +function directMapping( + remainingRequest, + isPattern, + isSubpathMapping, + mappingTarget, + conditionNames, + assert, +) { + if (mappingTarget === null) return []; + + if (typeof mappingTarget === "string") { + return [ + targetMapping( + remainingRequest, + isPattern, + isSubpathMapping, + mappingTarget, + assert, + ), + ]; + } + + /** @type {string[]} */ + const targets = []; + + for (const exp of mappingTarget) { + if (typeof exp === "string") { + targets.push( + targetMapping( + remainingRequest, + isPattern, + isSubpathMapping, + exp, + assert, + ), + ); + continue; + } + + const mapping = conditionalMapping(exp, conditionNames); + if (!mapping) continue; + const innerExports = directMapping( + remainingRequest, + isPattern, + isSubpathMapping, + mapping, + conditionNames, + assert, + ); + for (const innerExport of innerExports) { + targets.push(innerExport); + } + } + + return targets; +} + +/** + * @param {ExportsField | ImportsField} field root + * @param {(s: string) => string} normalizeRequest Normalize request, for `imports` field it adds `#`, for `exports` field it adds `.` or `./` + * @param {(s: string) => string} assertRequest assertRequest + * @param {(s: string, f: boolean) => void} assertTarget assertTarget + * @returns {FieldProcessor} field processor + */ +function createFieldProcessor( + field, + normalizeRequest, + assertRequest, + assertTarget, +) { + return function fieldProcessor(request, conditionNames) { + request = assertRequest(request); + + const match = findMatch(normalizeRequest(request), field); + + if (match === null) return [[], null]; + + const [mapping, remainingRequest, isSubpathMapping, isPattern, usedField] = + match; + + /** @type {DirectMapping | null} */ + let direct = null; + + if (isConditionalMapping(mapping)) { + direct = conditionalMapping( + /** @type {ConditionalMapping} */ (mapping), + conditionNames, + ); + + // matching not found + if (direct === null) return [[], null]; + } else { + direct = /** @type {DirectMapping} */ (mapping); + } + + return [ + directMapping( + remainingRequest, + isPattern, + isSubpathMapping, + direct, + conditionNames, + assertTarget, + ), + usedField, + ]; + }; +} + +/** + * @param {string} request request + * @returns {string} updated request + */ +function assertExportsFieldRequest(request) { + if (request.charCodeAt(0) !== dotCode) { + throw new Error('Request should be relative path and start with "."'); + } + if (request.length === 1) return ""; + if (request.charCodeAt(1) !== slashCode) { + throw new Error('Request should be relative path and start with "./"'); + } + if (request.charCodeAt(request.length - 1) === slashCode) { + throw new Error("Only requesting file allowed"); + } + + return request.slice(2); +} + +/** + * @param {ExportsField} field exports field + * @returns {ExportsField} normalized exports field + */ +function buildExportsField(field) { + // handle syntax sugar, if exports field is direct mapping for "." + if (typeof field === "string" || Array.isArray(field)) { + return { ".": field }; + } + + const keys = Object.keys(field); + + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + + if (key.charCodeAt(0) !== dotCode) { + // handle syntax sugar, if exports field is conditional mapping for "." + if (i === 0) { + while (i < keys.length) { + const charCode = keys[i].charCodeAt(0); + if (charCode === dotCode || charCode === slashCode) { + throw new Error( + `Exports field key should be relative path and start with "." (key: ${JSON.stringify( + key, + )})`, + ); + } + i++; + } + + return { ".": field }; + } + + throw new Error( + `Exports field key should be relative path and start with "." (key: ${JSON.stringify( + key, + )})`, + ); + } + + if (key.length === 1) { + continue; + } + + if (key.charCodeAt(1) !== slashCode) { + throw new Error( + `Exports field key should be relative path and start with "./" (key: ${JSON.stringify( + key, + )})`, + ); + } + } + + return field; +} + +/** + * @param {string} exp export target + * @param {boolean} expectFolder is folder expected + */ +function assertExportTarget(exp, expectFolder) { + const parsedIdentifier = parseIdentifier(exp); + + if (!parsedIdentifier) { + return; + } + + const [relativePath] = parsedIdentifier; + const isFolder = + relativePath.charCodeAt(relativePath.length - 1) === slashCode; + + if (isFolder !== expectFolder) { + throw new Error( + expectFolder + ? `Expecting folder to folder mapping. ${JSON.stringify( + exp, + )} should end with "/"` + : `Expecting file to file mapping. ${JSON.stringify( + exp, + )} should not end with "/"`, + ); + } +} + +/** + * @param {ExportsField} exportsField the exports field + * @returns {FieldProcessor} process callback + */ +module.exports.processExportsField = function processExportsField( + exportsField, +) { + return createFieldProcessor( + buildExportsField(exportsField), + (request) => (request.length === 0 ? "." : `./${request}`), + assertExportsFieldRequest, + assertExportTarget, + ); +}; + +/** + * @param {string} request request + * @returns {string} updated request + */ +function assertImportsFieldRequest(request) { + if (request.charCodeAt(0) !== hashCode) { + throw new Error('Request should start with "#"'); + } + if (request.length === 1) { + throw new Error("Request should have at least 2 characters"); + } + if (request.charCodeAt(1) === slashCode) { + throw new Error('Request should not start with "#/"'); + } + if (request.charCodeAt(request.length - 1) === slashCode) { + throw new Error("Only requesting file allowed"); + } + + return request.slice(1); +} + +/** + * @param {string} imp import target + * @param {boolean} expectFolder is folder expected + */ +function assertImportTarget(imp, expectFolder) { + const parsedIdentifier = parseIdentifier(imp); + + if (!parsedIdentifier) { + return; + } + + const [relativePath] = parsedIdentifier; + const isFolder = + relativePath.charCodeAt(relativePath.length - 1) === slashCode; + + if (isFolder !== expectFolder) { + throw new Error( + expectFolder + ? `Expecting folder to folder mapping. ${JSON.stringify( + imp, + )} should end with "/"` + : `Expecting file to file mapping. ${JSON.stringify( + imp, + )} should not end with "/"`, + ); + } +} + +/** + * @param {ImportsField} importsField the exports field + * @returns {FieldProcessor} process callback + */ +module.exports.processImportsField = function processImportsField( + importsField, +) { + return createFieldProcessor( + importsField, + (request) => `#${request}`, + assertImportsFieldRequest, + assertImportTarget, + ); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/util/identifier.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/util/identifier.js new file mode 100644 index 0000000000000000000000000000000000000000..be06d0fbded00b1acd425c6fe3aa2c745b7049ef --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/util/identifier.js @@ -0,0 +1,69 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Ivan Kopeykin @vankop +*/ + +"use strict"; + +const PATH_QUERY_FRAGMENT_REGEXP = + /^(#?(?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/; +const ZERO_ESCAPE_REGEXP = /\0(.)/g; + +/** + * @param {string} identifier identifier + * @returns {[string, string, string]|null} parsed identifier + */ +function parseIdentifier(identifier) { + if (!identifier) { + return null; + } + + const firstEscape = identifier.indexOf("\0"); + if (firstEscape < 0) { + // Fast path for inputs that don't use \0 escaping. + const queryStart = identifier.indexOf("?"); + // Start at index 1 to ignore a possible leading hash. + const fragmentStart = identifier.indexOf("#", 1); + + if (fragmentStart < 0) { + if (queryStart < 0) { + // No fragment, no query + return [identifier, "", ""]; + } + // Query, no fragment + return [ + identifier.slice(0, queryStart), + identifier.slice(queryStart), + "", + ]; + } + + if (queryStart < 0 || fragmentStart < queryStart) { + // Fragment, no query + return [ + identifier.slice(0, fragmentStart), + "", + identifier.slice(fragmentStart), + ]; + } + + // Query and fragment + return [ + identifier.slice(0, queryStart), + identifier.slice(queryStart, fragmentStart), + identifier.slice(fragmentStart), + ]; + } + + const match = PATH_QUERY_FRAGMENT_REGEXP.exec(identifier); + + if (!match) return null; + + return [ + match[1].replace(ZERO_ESCAPE_REGEXP, "$1"), + match[2] ? match[2].replace(ZERO_ESCAPE_REGEXP, "$1") : "", + match[3] || "", + ]; +} + +module.exports.parseIdentifier = parseIdentifier; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/util/memoize.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/util/memoize.js new file mode 100644 index 0000000000000000000000000000000000000000..b46e252ad6a2e1d4901a6c06c84b47f174a3d9a9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/util/memoize.js @@ -0,0 +1,37 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +/** + * @template T + * @typedef {() => T} FunctionReturning + */ + +/** + * @template T + * @param {FunctionReturning} fn memorized function + * @returns {FunctionReturning} new function + */ +const memoize = (fn) => { + let cache = false; + /** @type {T | undefined} */ + let result; + return () => { + if (cache) { + return /** @type {T} */ (result); + } + + result = fn(); + cache = true; + // Allow to clean up memory for fn + // and all dependent resources + /** @type {FunctionReturning | undefined} */ + (fn) = undefined; + return /** @type {T} */ (result); + }; +}; + +module.exports = memoize; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/util/module-browser.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/util/module-browser.js new file mode 100644 index 0000000000000000000000000000000000000000..1258c22e150fe2a691a8bc3589cd5fcd575edf7f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/util/module-browser.js @@ -0,0 +1,8 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +module.exports = {}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/util/path.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/util/path.js new file mode 100644 index 0000000000000000000000000000000000000000..af3404697194b76c554275bdd5cd98cd2a117f43 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/util/path.js @@ -0,0 +1,203 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +const path = require("path"); + +const CHAR_HASH = "#".charCodeAt(0); +const CHAR_SLASH = "/".charCodeAt(0); +const CHAR_BACKSLASH = "\\".charCodeAt(0); +const CHAR_A = "A".charCodeAt(0); +const CHAR_Z = "Z".charCodeAt(0); +const CHAR_LOWER_A = "a".charCodeAt(0); +const CHAR_LOWER_Z = "z".charCodeAt(0); +const CHAR_DOT = ".".charCodeAt(0); +const CHAR_COLON = ":".charCodeAt(0); + +const posixNormalize = path.posix.normalize; +const winNormalize = path.win32.normalize; + +/** + * @enum {number} + */ +const PathType = Object.freeze({ + Empty: 0, + Normal: 1, + Relative: 2, + AbsoluteWin: 3, + AbsolutePosix: 4, + Internal: 5, +}); + +const deprecatedInvalidSegmentRegEx = + /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))(\\|\/|$)/i; + +const invalidSegmentRegEx = + /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))?(\\|\/|$)/i; + +/** + * @param {string} maybePath a path + * @returns {PathType} type of path + */ +const getType = (maybePath) => { + switch (maybePath.length) { + case 0: + return PathType.Empty; + case 1: { + const c0 = maybePath.charCodeAt(0); + switch (c0) { + case CHAR_DOT: + return PathType.Relative; + case CHAR_SLASH: + return PathType.AbsolutePosix; + case CHAR_HASH: + return PathType.Internal; + } + return PathType.Normal; + } + case 2: { + const c0 = maybePath.charCodeAt(0); + switch (c0) { + case CHAR_DOT: { + const c1 = maybePath.charCodeAt(1); + switch (c1) { + case CHAR_DOT: + case CHAR_SLASH: + return PathType.Relative; + } + return PathType.Normal; + } + case CHAR_SLASH: + return PathType.AbsolutePosix; + case CHAR_HASH: + return PathType.Internal; + } + const c1 = maybePath.charCodeAt(1); + if ( + c1 === CHAR_COLON && + ((c0 >= CHAR_A && c0 <= CHAR_Z) || + (c0 >= CHAR_LOWER_A && c0 <= CHAR_LOWER_Z)) + ) { + return PathType.AbsoluteWin; + } + return PathType.Normal; + } + } + const c0 = maybePath.charCodeAt(0); + switch (c0) { + case CHAR_DOT: { + const c1 = maybePath.charCodeAt(1); + switch (c1) { + case CHAR_SLASH: + return PathType.Relative; + case CHAR_DOT: { + const c2 = maybePath.charCodeAt(2); + if (c2 === CHAR_SLASH) return PathType.Relative; + return PathType.Normal; + } + } + return PathType.Normal; + } + case CHAR_SLASH: + return PathType.AbsolutePosix; + case CHAR_HASH: + return PathType.Internal; + } + const c1 = maybePath.charCodeAt(1); + if (c1 === CHAR_COLON) { + const c2 = maybePath.charCodeAt(2); + if ( + (c2 === CHAR_BACKSLASH || c2 === CHAR_SLASH) && + ((c0 >= CHAR_A && c0 <= CHAR_Z) || + (c0 >= CHAR_LOWER_A && c0 <= CHAR_LOWER_Z)) + ) { + return PathType.AbsoluteWin; + } + } + return PathType.Normal; +}; + +/** + * @param {string} maybePath a path + * @returns {string} the normalized path + */ +const normalize = (maybePath) => { + switch (getType(maybePath)) { + case PathType.Empty: + return maybePath; + case PathType.AbsoluteWin: + return winNormalize(maybePath); + case PathType.Relative: { + const r = posixNormalize(maybePath); + return getType(r) === PathType.Relative ? r : `./${r}`; + } + } + return posixNormalize(maybePath); +}; + +/** + * @param {string} rootPath the root path + * @param {string | undefined} request the request path + * @returns {string} the joined path + */ +const join = (rootPath, request) => { + if (!request) return normalize(rootPath); + const requestType = getType(request); + switch (requestType) { + case PathType.AbsolutePosix: + return posixNormalize(request); + case PathType.AbsoluteWin: + return winNormalize(request); + } + switch (getType(rootPath)) { + case PathType.Normal: + case PathType.Relative: + case PathType.AbsolutePosix: + return posixNormalize(`${rootPath}/${request}`); + case PathType.AbsoluteWin: + return winNormalize(`${rootPath}\\${request}`); + } + switch (requestType) { + case PathType.Empty: + return rootPath; + case PathType.Relative: { + const r = posixNormalize(rootPath); + return getType(r) === PathType.Relative ? r : `./${r}`; + } + } + return posixNormalize(rootPath); +}; + +/** @type {Map>} */ +const joinCache = new Map(); + +/** + * @param {string} rootPath the root path + * @param {string} request the request path + * @returns {string} the joined path + */ +const cachedJoin = (rootPath, request) => { + /** @type {string | undefined} */ + let cacheEntry; + let cache = joinCache.get(rootPath); + if (cache === undefined) { + joinCache.set(rootPath, (cache = new Map())); + } else { + cacheEntry = cache.get(request); + if (cacheEntry !== undefined) return cacheEntry; + } + cacheEntry = join(rootPath, request); + cache.set(request, cacheEntry); + return cacheEntry; +}; + +module.exports.PathType = PathType; +module.exports.cachedJoin = cachedJoin; +module.exports.deprecatedInvalidSegmentRegEx = deprecatedInvalidSegmentRegEx; +module.exports.getType = getType; +module.exports.invalidSegmentRegEx = invalidSegmentRegEx; +module.exports.join = join; +module.exports.normalize = normalize; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/util/process-browser.js b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/util/process-browser.js new file mode 100644 index 0000000000000000000000000000000000000000..694334c87e1a47dfda9f668b2ed4e434cab65443 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/enhanced-resolve/lib/util/process-browser.js @@ -0,0 +1,25 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +"use strict"; + +module.exports = { + /** + * @type {Record} + */ + versions: {}, + // eslint-disable-next-line jsdoc/no-restricted-syntax + /** + * @param {Function} fn function + */ + nextTick(fn) { + // eslint-disable-next-line prefer-rest-params + const args = Array.prototype.slice.call(arguments, 1); + Promise.resolve().then(() => { + // eslint-disable-next-line prefer-spread + fn.apply(null, args); + }); + }, +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/AbstractEqualityComparison.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/AbstractEqualityComparison.js new file mode 100644 index 0000000000000000000000000000000000000000..04522eabb827592704c5e463cb3528566fca845f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/AbstractEqualityComparison.js @@ -0,0 +1,38 @@ +'use strict'; + +var ToNumber = require('./ToNumber'); +var ToPrimitive = require('./ToPrimitive'); + +var isSameType = require('../helpers/isSameType'); + +var isObject = require('es-object-atoms/isObject'); + +// https://262.ecma-international.org/6.0/#sec-abstract-equality-comparison + +module.exports = function AbstractEqualityComparison(x, y) { + if (isSameType(x, y)) { + return x === y; // ES6+ specified this shortcut anyways. + } + if (x == null && y == null) { + return true; + } + if (typeof x === 'number' && typeof y === 'string') { + return AbstractEqualityComparison(x, ToNumber(y)); + } + if (typeof x === 'string' && typeof y === 'number') { + return AbstractEqualityComparison(ToNumber(x), y); + } + if (typeof x === 'boolean') { + return AbstractEqualityComparison(ToNumber(x), y); + } + if (typeof y === 'boolean') { + return AbstractEqualityComparison(x, ToNumber(y)); + } + if ((typeof x === 'string' || typeof x === 'number' || typeof x === 'symbol') && isObject(y)) { + return AbstractEqualityComparison(x, ToPrimitive(y)); + } + if (isObject(x) && (typeof y === 'string' || typeof y === 'number' || typeof y === 'symbol')) { + return AbstractEqualityComparison(ToPrimitive(x), y); + } + return false; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/AbstractRelationalComparison.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/AbstractRelationalComparison.js new file mode 100644 index 0000000000000000000000000000000000000000..443cfe0c767c876171b94fd060556bd037666807 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/AbstractRelationalComparison.js @@ -0,0 +1,62 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $Number = GetIntrinsic('%Number%'); +var $TypeError = require('es-errors/type'); +var $isNaN = require('math-intrinsics/isNaN'); +var $isFinite = require('math-intrinsics/isFinite'); + +var isPrefixOf = require('../helpers/isPrefixOf'); + +var ToNumber = require('./ToNumber'); +var ToPrimitive = require('./ToPrimitive'); + +// https://262.ecma-international.org/5.1/#sec-11.8.5 + +// eslint-disable-next-line max-statements +module.exports = function AbstractRelationalComparison(x, y, LeftFirst) { + if (typeof LeftFirst !== 'boolean') { + throw new $TypeError('Assertion failed: LeftFirst argument must be a Boolean'); + } + var px; + var py; + if (LeftFirst) { + px = ToPrimitive(x, $Number); + py = ToPrimitive(y, $Number); + } else { + py = ToPrimitive(y, $Number); + px = ToPrimitive(x, $Number); + } + var bothStrings = typeof px === 'string' && typeof py === 'string'; + if (!bothStrings) { + var nx = ToNumber(px); + var ny = ToNumber(py); + if ($isNaN(nx) || $isNaN(ny)) { + return undefined; + } + if ($isFinite(nx) && $isFinite(ny) && nx === ny) { + return false; + } + if (nx === Infinity) { + return false; + } + if (ny === Infinity) { + return true; + } + if (ny === -Infinity) { + return false; + } + if (nx === -Infinity) { + return true; + } + return nx < ny; // by now, these are both nonzero, finite, and not equal + } + if (isPrefixOf(py, px)) { + return false; + } + if (isPrefixOf(px, py)) { + return true; + } + return px < py; // both strings, neither a prefix of the other. shortcut for steps c-f +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/AdvanceStringIndex.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/AdvanceStringIndex.js new file mode 100644 index 0000000000000000000000000000000000000000..dac7a286dca6f3d387e9f7057eeb0739cc48be23 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/AdvanceStringIndex.js @@ -0,0 +1,44 @@ +'use strict'; + +var isInteger = require('math-intrinsics/isInteger'); +var MAX_SAFE_INTEGER = require('math-intrinsics/constants/maxSafeInteger'); + +var isLeadingSurrogate = require('../helpers/isLeadingSurrogate'); +var isTrailingSurrogate = require('../helpers/isTrailingSurrogate'); + +var $TypeError = require('es-errors/type'); + +var $charCodeAt = require('call-bound')('String.prototype.charCodeAt'); + +// https://262.ecma-international.org/6.0/#sec-advancestringindex + +module.exports = function AdvanceStringIndex(S, index, unicode) { + if (typeof S !== 'string') { + throw new $TypeError('Assertion failed: `S` must be a String'); + } + if (!isInteger(index) || index < 0 || index > MAX_SAFE_INTEGER) { + throw new $TypeError('Assertion failed: `length` must be an integer >= 0 and <= 2**53'); + } + if (typeof unicode !== 'boolean') { + throw new $TypeError('Assertion failed: `unicode` must be a Boolean'); + } + if (!unicode) { + return index + 1; + } + var length = S.length; + if ((index + 1) >= length) { + return index + 1; + } + + var first = $charCodeAt(S, index); + if (!isLeadingSurrogate(first)) { + return index + 1; + } + + var second = $charCodeAt(S, index + 1); + if (!isTrailingSurrogate(second)) { + return index + 1; + } + + return index + 2; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ArrayCreate.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ArrayCreate.js new file mode 100644 index 0000000000000000000000000000000000000000..8ed55aa2950b86640e487c905e4b73c543d71680 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ArrayCreate.js @@ -0,0 +1,42 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $ArrayPrototype = GetIntrinsic('%Array.prototype%'); +var $RangeError = require('es-errors/range'); +var $SyntaxError = require('es-errors/syntax'); +var $TypeError = require('es-errors/type'); +var isInteger = require('math-intrinsics/isInteger'); +var MAX_ARRAY_LENGTH = require('math-intrinsics/constants/maxArrayLength'); +var $setProto = require('set-proto'); + +// https://262.ecma-international.org/6.0/#sec-arraycreate + +module.exports = function ArrayCreate(length) { + if (!isInteger(length) || length < 0) { + throw new $TypeError('Assertion failed: `length` must be an integer Number >= 0'); + } + if (length > MAX_ARRAY_LENGTH) { + throw new $RangeError('length is greater than (2**32 - 1)'); + } + var proto = arguments.length > 1 ? arguments[1] : $ArrayPrototype; + var A = []; // steps 5 - 7, and 9 + if (proto !== $ArrayPrototype) { // step 8 + if (!$setProto) { + throw new $SyntaxError('ArrayCreate: a `proto` argument that is not `Array.prototype` is not supported in an environment that does not support setting the [[Prototype]]'); + } + $setProto(A, proto); + } + if (length !== 0) { // bypasses the need for step 2 + A.length = length; + } + /* step 10, the above as a shortcut for the below + OrdinaryDefineOwnProperty(A, 'length', { + '[[Configurable]]': false, + '[[Enumerable]]': false, + '[[Value]]': length, + '[[Writable]]': true + }); + */ + return A; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ArraySetLength.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ArraySetLength.js new file mode 100644 index 0000000000000000000000000000000000000000..7f7a4339c2af5c8656165189f47c4212732ee1bd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ArraySetLength.js @@ -0,0 +1,77 @@ +'use strict'; + +var $RangeError = require('es-errors/range'); +var $TypeError = require('es-errors/type'); + +var assign = require('object.assign'); + +var isPropertyDescriptor = require('../helpers/records/property-descriptor'); + +var IsArray = require('./IsArray'); +var IsDataDescriptor = require('./IsDataDescriptor'); +var OrdinaryDefineOwnProperty = require('./OrdinaryDefineOwnProperty'); +var OrdinaryGetOwnProperty = require('./OrdinaryGetOwnProperty'); +var ToNumber = require('./ToNumber'); +var ToString = require('./ToString'); +var ToUint32 = require('./ToUint32'); + +// https://262.ecma-international.org/6.0/#sec-arraysetlength + +// eslint-disable-next-line max-statements, max-lines-per-function +module.exports = function ArraySetLength(A, Desc) { + if (!IsArray(A)) { + throw new $TypeError('Assertion failed: A must be an Array'); + } + if (!isPropertyDescriptor(Desc)) { + throw new $TypeError('Assertion failed: Desc must be a Property Descriptor'); + } + if (!('[[Value]]' in Desc)) { + return OrdinaryDefineOwnProperty(A, 'length', Desc); + } + var newLenDesc = assign({}, Desc); + var newLen = ToUint32(Desc['[[Value]]']); + var numberLen = ToNumber(Desc['[[Value]]']); + if (newLen !== numberLen) { + throw new $RangeError('Invalid array length'); + } + newLenDesc['[[Value]]'] = newLen; + var oldLenDesc = OrdinaryGetOwnProperty(A, 'length'); + if (!IsDataDescriptor(oldLenDesc)) { + throw new $TypeError('Assertion failed: an array had a non-data descriptor on `length`'); + } + var oldLen = oldLenDesc['[[Value]]']; + if (newLen >= oldLen) { + return OrdinaryDefineOwnProperty(A, 'length', newLenDesc); + } + if (!oldLenDesc['[[Writable]]']) { + return false; + } + var newWritable; + if (!('[[Writable]]' in newLenDesc) || newLenDesc['[[Writable]]']) { + newWritable = true; + } else { + newWritable = false; + newLenDesc['[[Writable]]'] = true; + } + var succeeded = OrdinaryDefineOwnProperty(A, 'length', newLenDesc); + if (!succeeded) { + return false; + } + while (newLen < oldLen) { + oldLen -= 1; + // eslint-disable-next-line no-param-reassign + var deleteSucceeded = delete A[ToString(oldLen)]; + if (!deleteSucceeded) { + newLenDesc['[[Value]]'] = oldLen + 1; + if (!newWritable) { + newLenDesc['[[Writable]]'] = false; + OrdinaryDefineOwnProperty(A, 'length', newLenDesc); + return false; + } + } + } + if (!newWritable) { + return OrdinaryDefineOwnProperty(A, 'length', { '[[Writable]]': false }); + } + return true; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ArraySpeciesCreate.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ArraySpeciesCreate.js new file mode 100644 index 0000000000000000000000000000000000000000..8be185bd97d9c1d975ac93d279dd9d502790e51b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ArraySpeciesCreate.js @@ -0,0 +1,46 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $Array = GetIntrinsic('%Array%'); +var $species = GetIntrinsic('%Symbol.species%', true); +var $TypeError = require('es-errors/type'); +var isInteger = require('math-intrinsics/isInteger'); +var isObject = require('es-object-atoms/isObject'); + +var Get = require('./Get'); +var IsArray = require('./IsArray'); +var IsConstructor = require('./IsConstructor'); + +// https://262.ecma-international.org/6.0/#sec-arrayspeciescreate + +module.exports = function ArraySpeciesCreate(originalArray, length) { + if (!isInteger(length) || length < 0) { + throw new $TypeError('Assertion failed: length must be an integer >= 0'); + } + var len = length === 0 ? 0 : length; + var C; + var isArray = IsArray(originalArray); + if (isArray) { + C = Get(originalArray, 'constructor'); + // TODO: figure out how to make a cross-realm normal Array, a same-realm Array + // if (IsConstructor(C)) { + // if C is another realm's Array, C = undefined + // Object.getPrototypeOf(Object.getPrototypeOf(Object.getPrototypeOf(Array))) === null ? + // } + if ($species && isObject(C)) { + C = Get(C, $species); + if (C === null) { + C = void 0; + } + } + } + if (typeof C === 'undefined') { + return $Array(len); + } + if (!IsConstructor(C)) { + throw new $TypeError('C must be a constructor'); + } + return new C(len); // Construct(C, len); +}; + diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/Call.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/Call.js new file mode 100644 index 0000000000000000000000000000000000000000..90b3519cb954848f531c4921eaa79ec7d37d06bd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/Call.js @@ -0,0 +1,20 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); +var callBound = require('call-bound'); + +var $TypeError = require('es-errors/type'); + +var IsArray = require('./IsArray'); + +var $apply = GetIntrinsic('%Reflect.apply%', true) || callBound('Function.prototype.apply'); + +// https://262.ecma-international.org/6.0/#sec-call + +module.exports = function Call(F, V) { + var argumentsList = arguments.length > 2 ? arguments[2] : []; + if (!IsArray(argumentsList)) { + throw new $TypeError('Assertion failed: optional `argumentsList`, if provided, must be a List'); + } + return $apply(F, V, argumentsList); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CanonicalNumericIndexString.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CanonicalNumericIndexString.js new file mode 100644 index 0000000000000000000000000000000000000000..74ed02f050d21c13dbfc06c80c21ae20a8e530ee --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CanonicalNumericIndexString.js @@ -0,0 +1,19 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var SameValue = require('./SameValue'); +var ToNumber = require('./ToNumber'); +var ToString = require('./ToString'); + +// https://262.ecma-international.org/6.0/#sec-canonicalnumericindexstring + +module.exports = function CanonicalNumericIndexString(argument) { + if (typeof argument !== 'string') { + throw new $TypeError('Assertion failed: `argument` must be a String'); + } + if (argument === '-0') { return -0; } + var n = ToNumber(argument); + if (SameValue(ToString(n), argument)) { return n; } + return void 0; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/Canonicalize.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/Canonicalize.js new file mode 100644 index 0000000000000000000000000000000000000000..63a58c4028e12d41fc2775615441ea23228b6719 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/Canonicalize.js @@ -0,0 +1,51 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var callBound = require('call-bound'); +var hasOwn = require('hasown'); + +var $charCodeAt = callBound('String.prototype.charCodeAt'); +var $toUpperCase = callBound('String.prototype.toUpperCase'); + +var caseFolding = require('../helpers/caseFolding.json'); + +// https://262.ecma-international.org/6.0/#sec-runtime-semantics-canonicalize-ch + +module.exports = function Canonicalize(ch, IgnoreCase, Unicode) { + if (typeof ch !== 'string') { + throw new $TypeError('Assertion failed: `ch` must be a character'); + } + + if (typeof IgnoreCase !== 'boolean' || typeof Unicode !== 'boolean') { + throw new $TypeError('Assertion failed: `IgnoreCase` and `Unicode` must be Booleans'); + } + + if (!IgnoreCase) { + return ch; // step 1 + } + + if (Unicode) { // step 2 + if (hasOwn(caseFolding.C, ch)) { + return caseFolding.C[ch]; + } + if (hasOwn(caseFolding.S, ch)) { + return caseFolding.S[ch]; + } + return ch; // step 2.b + } + + var u = $toUpperCase(ch); // step 2 + + if (u.length !== 1) { + return ch; // step 3 + } + + var cu = u; // step 4 + + if ($charCodeAt(ch, 0) >= 128 && $charCodeAt(cu, 0) < 128) { + return ch; // step 5 + } + + return cu; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CharacterRange.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CharacterRange.js new file mode 100644 index 0000000000000000000000000000000000000000..e41cb7870a7411344a21dfe7fbfc7cd6888b7c9e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CharacterRange.js @@ -0,0 +1,53 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); +var callBound = require('call-bound'); + +var $fromCharCode = GetIntrinsic('%String.fromCharCode%'); +var $TypeError = require('es-errors/type'); +var $charCodeAt = callBound('String.prototype.charCodeAt'); + +var CharSet = require('../helpers/CharSet').CharSet; + +module.exports = function CharacterRange(A, B) { + var a; + var b; + + if (A instanceof CharSet || B instanceof CharSet) { + if (!(A instanceof CharSet) || !(B instanceof CharSet)) { + throw new $TypeError('Assertion failed: CharSets A and B are not both CharSets'); + } + + A.yield(function (c) { + if (typeof a !== 'undefined') { + throw new $TypeError('Assertion failed: CharSet A has more than one character'); + } + a = c; + }); + B.yield(function (c) { + if (typeof b !== 'undefined') { + throw new $TypeError('Assertion failed: CharSet B has more than one character'); + } + b = c; + }); + } else { + if (A.length !== 1 || B.length !== 1) { + throw new $TypeError('Assertion failed: CharSets A and B contain exactly one character'); + } + a = A[0]; + b = B[0]; + } + + var i = $charCodeAt(a, 0); + var j = $charCodeAt(b, 0); + + if (!(i <= j)) { + throw new $TypeError('Assertion failed: i is not <= j'); + } + + var arr = []; + for (var k = i; k <= j; k += 1) { + arr[arr.length] = $fromCharCode(k); + } + return arr; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CompletePropertyDescriptor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CompletePropertyDescriptor.js new file mode 100644 index 0000000000000000000000000000000000000000..8c9e3f441111638a3b3c9fd69857d3da22c779ee --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CompletePropertyDescriptor.js @@ -0,0 +1,43 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var hasOwn = require('hasown'); + +var IsDataDescriptor = require('./IsDataDescriptor'); +var IsGenericDescriptor = require('./IsGenericDescriptor'); + +var isPropertyDescriptor = require('../helpers/records/property-descriptor'); + +// https://262.ecma-international.org/6.0/#sec-completepropertydescriptor + +module.exports = function CompletePropertyDescriptor(Desc) { + if (!isPropertyDescriptor(Desc)) { + throw new $TypeError('Assertion failed: `Desc` must be a Property Descriptor'); + } + + /* eslint no-param-reassign: 0 */ + + if (IsGenericDescriptor(Desc) || IsDataDescriptor(Desc)) { + if (!hasOwn(Desc, '[[Value]]')) { + Desc['[[Value]]'] = void 0; + } + if (!hasOwn(Desc, '[[Writable]]')) { + Desc['[[Writable]]'] = false; + } + } else { + if (!hasOwn(Desc, '[[Get]]')) { + Desc['[[Get]]'] = void 0; + } + if (!hasOwn(Desc, '[[Set]]')) { + Desc['[[Set]]'] = void 0; + } + } + if (!hasOwn(Desc, '[[Enumerable]]')) { + Desc['[[Enumerable]]'] = false; + } + if (!hasOwn(Desc, '[[Configurable]]')) { + Desc['[[Configurable]]'] = false; + } + return Desc; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CompletionRecord.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CompletionRecord.js new file mode 100644 index 0000000000000000000000000000000000000000..6f5b874d25c97eeedb49933e964e0dc1c6d34583 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CompletionRecord.js @@ -0,0 +1,48 @@ +'use strict'; + +var $SyntaxError = require('es-errors/syntax'); + +var SLOT = require('internal-slot'); + +// https://262.ecma-international.org/6.0/#sec-completion-record-specification-type + +var CompletionRecord = function CompletionRecord(type, value) { + if (!(this instanceof CompletionRecord)) { + return new CompletionRecord(type, value); + } + if (type !== 'normal' && type !== 'break' && type !== 'continue' && type !== 'return' && type !== 'throw') { + throw new $SyntaxError('Assertion failed: `type` must be one of "normal", "break", "continue", "return", or "throw"'); + } + SLOT.set(this, '[[type]]', type); + SLOT.set(this, '[[value]]', value); + // [[target]] slot? +}; + +CompletionRecord.prototype.type = function type() { + return SLOT.get(this, '[[type]]'); +}; + +CompletionRecord.prototype.value = function value() { + return SLOT.get(this, '[[value]]'); +}; + +CompletionRecord.prototype['?'] = function ReturnIfAbrupt() { + var type = SLOT.get(this, '[[type]]'); + var value = SLOT.get(this, '[[value]]'); + + if (type === 'throw') { + throw value; + } + return value; +}; + +CompletionRecord.prototype['!'] = function assert() { + var type = SLOT.get(this, '[[type]]'); + + if (type !== 'normal') { + throw new $SyntaxError('Assertion failed: Completion Record is not of type "normal"'); + } + return SLOT.get(this, '[[value]]'); +}; + +module.exports = CompletionRecord; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CreateDataProperty.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CreateDataProperty.js new file mode 100644 index 0000000000000000000000000000000000000000..897617c0ca1e0365cb55a83855b0983550e3e298 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CreateDataProperty.js @@ -0,0 +1,25 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var isPropertyKey = require('../helpers/isPropertyKey'); +var OrdinaryDefineOwnProperty = require('./OrdinaryDefineOwnProperty'); + +// https://262.ecma-international.org/6.0/#sec-createdataproperty + +module.exports = function CreateDataProperty(O, P, V) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: Type(O) is not Object'); + } + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: P is not a Property Key'); + } + var newDesc = { + '[[Configurable]]': true, + '[[Enumerable]]': true, + '[[Value]]': V, + '[[Writable]]': true + }; + return OrdinaryDefineOwnProperty(O, P, newDesc); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CreateDataPropertyOrThrow.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CreateDataPropertyOrThrow.js new file mode 100644 index 0000000000000000000000000000000000000000..42327aaef58a8ffc3c320851135e886106dcbad6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CreateDataPropertyOrThrow.js @@ -0,0 +1,24 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var CreateDataProperty = require('./CreateDataProperty'); + +var isPropertyKey = require('../helpers/isPropertyKey'); + +// // https://262.ecma-international.org/6.0/#sec-createdatapropertyorthrow + +module.exports = function CreateDataPropertyOrThrow(O, P, V) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: Type(O) is not Object'); + } + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: P is not a Property Key'); + } + var success = CreateDataProperty(O, P, V); + if (!success) { + throw new $TypeError('unable to create data property'); + } + return success; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CreateHTML.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CreateHTML.js new file mode 100644 index 0000000000000000000000000000000000000000..25630f43085954792b398e93a870ac78b46e3fc4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CreateHTML.js @@ -0,0 +1,27 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var callBound = require('call-bound'); + +var $replace = callBound('String.prototype.replace'); + +var RequireObjectCoercible = require('./RequireObjectCoercible'); +var ToString = require('./ToString'); + +// https://262.ecma-international.org/6.0/#sec-createhtml + +module.exports = function CreateHTML(string, tag, attribute, value) { + if (typeof tag !== 'string' || typeof attribute !== 'string') { + throw new $TypeError('Assertion failed: `tag` and `attribute` must be strings'); + } + var str = RequireObjectCoercible(string); + var S = ToString(str); + var p1 = '<' + tag; + if (attribute !== '') { + var V = ToString(value); + var escapedV = $replace(V, /\x22/g, '"'); + p1 += '\x20' + attribute + '\x3D\x22' + escapedV + '\x22'; + } + return p1 + '>' + S + ''; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CreateIterResultObject.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CreateIterResultObject.js new file mode 100644 index 0000000000000000000000000000000000000000..679bdf00ea851b40cce0dc9e6d55526aa9d5c5d7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CreateIterResultObject.js @@ -0,0 +1,15 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +// https://262.ecma-international.org/6.0/#sec-createiterresultobject + +module.exports = function CreateIterResultObject(value, done) { + if (typeof done !== 'boolean') { + throw new $TypeError('Assertion failed: Type(done) is not Boolean'); + } + return { + value: value, + done: done + }; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CreateListFromArrayLike.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CreateListFromArrayLike.js new file mode 100644 index 0000000000000000000000000000000000000000..229f215c4db64cd944b0b646b7545eeac965f55b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CreateListFromArrayLike.js @@ -0,0 +1,43 @@ +'use strict'; + +var callBound = require('call-bound'); + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); +var $indexOf = callBound('Array.prototype.indexOf', true) || callBound('String.prototype.indexOf'); + +var Get = require('./Get'); +var IsArray = require('./IsArray'); +var ToLength = require('./ToLength'); +var ToString = require('./ToString'); +var Type = require('./Type'); + +var defaultElementTypes = ['Undefined', 'Null', 'Boolean', 'String', 'Symbol', 'Number', 'Object']; + +// https://262.ecma-international.org/6.0/#sec-createlistfromarraylike +module.exports = function CreateListFromArrayLike(obj) { + var elementTypes = arguments.length > 1 + ? arguments[1] + : defaultElementTypes; + + if (!isObject(obj)) { + throw new $TypeError('Assertion failed: `obj` must be an Object'); + } + if (!IsArray(elementTypes)) { + throw new $TypeError('Assertion failed: `elementTypes`, if provided, must be an array'); + } + var len = ToLength(Get(obj, 'length')); + var list = []; + var index = 0; + while (index < len) { + var indexName = ToString(index); + var next = Get(obj, indexName); + var nextType = Type(next); + if ($indexOf(elementTypes, nextType) < 0) { + throw new $TypeError('item type ' + nextType + ' is not a valid elementType'); + } + list[list.length] = next; + index += 1; + } + return list; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CreateMethodProperty.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CreateMethodProperty.js new file mode 100644 index 0000000000000000000000000000000000000000..4c53a40986ad2c0f6678b161465bca1ba569dd21 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/CreateMethodProperty.js @@ -0,0 +1,38 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var DefineOwnProperty = require('../helpers/DefineOwnProperty'); + +var FromPropertyDescriptor = require('./FromPropertyDescriptor'); +var IsDataDescriptor = require('./IsDataDescriptor'); +var isPropertyKey = require('../helpers/isPropertyKey'); +var SameValue = require('./SameValue'); + +// https://262.ecma-international.org/6.0/#sec-createmethodproperty + +module.exports = function CreateMethodProperty(O, P, V) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: Type(O) is not Object'); + } + + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: P is not a Property Key'); + } + + var newDesc = { + '[[Configurable]]': true, + '[[Enumerable]]': false, + '[[Value]]': V, + '[[Writable]]': true + }; + return DefineOwnProperty( + IsDataDescriptor, + SameValue, + FromPropertyDescriptor, + O, + P, + newDesc + ); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/DateFromTime.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/DateFromTime.js new file mode 100644 index 0000000000000000000000000000000000000000..ec7edcd295f8bdd79eb60e44d8a17bb0b90fd80d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/DateFromTime.js @@ -0,0 +1,52 @@ +'use strict'; + +var $EvalError = require('es-errors/eval'); + +var DayWithinYear = require('./DayWithinYear'); +var InLeapYear = require('./InLeapYear'); +var MonthFromTime = require('./MonthFromTime'); + +// https://262.ecma-international.org/5.1/#sec-15.9.1.5 + +module.exports = function DateFromTime(t) { + var m = MonthFromTime(t); + var d = DayWithinYear(t); + if (m === 0) { + return d + 1; + } + if (m === 1) { + return d - 30; + } + var leap = InLeapYear(t); + if (m === 2) { + return d - 58 - leap; + } + if (m === 3) { + return d - 89 - leap; + } + if (m === 4) { + return d - 119 - leap; + } + if (m === 5) { + return d - 150 - leap; + } + if (m === 6) { + return d - 180 - leap; + } + if (m === 7) { + return d - 211 - leap; + } + if (m === 8) { + return d - 242 - leap; + } + if (m === 9) { + return d - 272 - leap; + } + if (m === 10) { + return d - 303 - leap; + } + if (m === 11) { + return d - 333 - leap; + } + throw new $EvalError('Assertion failed: MonthFromTime returned an impossible value: ' + m); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/Day.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/Day.js new file mode 100644 index 0000000000000000000000000000000000000000..51d01033c81cbd356ff4da8010c166137364237d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/Day.js @@ -0,0 +1,11 @@ +'use strict'; + +var floor = require('./floor'); + +var msPerDay = require('../helpers/timeConstants').msPerDay; + +// https://262.ecma-international.org/5.1/#sec-15.9.1.2 + +module.exports = function Day(t) { + return floor(t / msPerDay); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/DayFromYear.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/DayFromYear.js new file mode 100644 index 0000000000000000000000000000000000000000..341bf22a6c19352ec6225944fb49adeed22983e8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/DayFromYear.js @@ -0,0 +1,10 @@ +'use strict'; + +var floor = require('./floor'); + +// https://262.ecma-international.org/5.1/#sec-15.9.1.3 + +module.exports = function DayFromYear(y) { + return (365 * (y - 1970)) + floor((y - 1969) / 4) - floor((y - 1901) / 100) + floor((y - 1601) / 400); +}; + diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/DayWithinYear.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/DayWithinYear.js new file mode 100644 index 0000000000000000000000000000000000000000..4c580940a58c58dcc3f7c2f96c5bca8e8237ebfc --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/DayWithinYear.js @@ -0,0 +1,11 @@ +'use strict'; + +var Day = require('./Day'); +var DayFromYear = require('./DayFromYear'); +var YearFromTime = require('./YearFromTime'); + +// https://262.ecma-international.org/5.1/#sec-15.9.1.4 + +module.exports = function DayWithinYear(t) { + return Day(t) - DayFromYear(YearFromTime(t)); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/DaysInYear.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/DaysInYear.js new file mode 100644 index 0000000000000000000000000000000000000000..7116c69027022323e41130f384db7cc3d35709f9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/DaysInYear.js @@ -0,0 +1,18 @@ +'use strict'; + +var modulo = require('./modulo'); + +// https://262.ecma-international.org/5.1/#sec-15.9.1.3 + +module.exports = function DaysInYear(y) { + if (modulo(y, 4) !== 0) { + return 365; + } + if (modulo(y, 100) !== 0) { + return 366; + } + if (modulo(y, 400) !== 0) { + return 365; + } + return 366; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/DefinePropertyOrThrow.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/DefinePropertyOrThrow.js new file mode 100644 index 0000000000000000000000000000000000000000..ff6683c3dc954ec27c072032bfcc0cfd70936587 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/DefinePropertyOrThrow.js @@ -0,0 +1,39 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var isPropertyDescriptor = require('../helpers/records/property-descriptor'); +var DefineOwnProperty = require('../helpers/DefineOwnProperty'); + +var FromPropertyDescriptor = require('./FromPropertyDescriptor'); +var IsDataDescriptor = require('./IsDataDescriptor'); +var isPropertyKey = require('../helpers/isPropertyKey'); +var SameValue = require('./SameValue'); +var ToPropertyDescriptor = require('./ToPropertyDescriptor'); + +// https://262.ecma-international.org/6.0/#sec-definepropertyorthrow + +module.exports = function DefinePropertyOrThrow(O, P, desc) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: Type(O) is not Object'); + } + + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: P is not a Property Key'); + } + + var Desc = isPropertyDescriptor(desc) ? desc : ToPropertyDescriptor(desc); + if (!isPropertyDescriptor(Desc)) { + throw new $TypeError('Assertion failed: Desc is not a valid Property Descriptor'); + } + + return DefineOwnProperty( + IsDataDescriptor, + SameValue, + FromPropertyDescriptor, + O, + P, + Desc + ); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/DeletePropertyOrThrow.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/DeletePropertyOrThrow.js new file mode 100644 index 0000000000000000000000000000000000000000..8841fda81f7663673367bdfc1af99794fb0ef747 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/DeletePropertyOrThrow.js @@ -0,0 +1,25 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var isPropertyKey = require('../helpers/isPropertyKey'); + +// https://262.ecma-international.org/6.0/#sec-deletepropertyorthrow + +module.exports = function DeletePropertyOrThrow(O, P) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: Type(O) is not Object'); + } + + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: P is not a Property Key'); + } + + // eslint-disable-next-line no-param-reassign + var success = delete O[P]; + if (!success) { + throw new $TypeError('Attempt to delete property failed.'); + } + return success; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/DetachArrayBuffer.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/DetachArrayBuffer.js new file mode 100644 index 0000000000000000000000000000000000000000..00639640cbf8177dc231ff439d56da0387ebb275 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/DetachArrayBuffer.js @@ -0,0 +1,38 @@ +'use strict'; + +var $SyntaxError = require('es-errors/syntax'); +var $TypeError = require('es-errors/type'); + +var isArrayBuffer = require('is-array-buffer'); + +var IsDetachedBuffer = require('./IsDetachedBuffer'); + +var MessageChannel; +try { + // eslint-disable-next-line global-require + MessageChannel = require('worker_threads').MessageChannel; // node 11.7+ +} catch (e) { /**/ } + +// https://262.ecma-international.org/6.0/#sec-detacharraybuffer + +/* globals postMessage */ + +module.exports = function DetachArrayBuffer(arrayBuffer) { + if (!isArrayBuffer(arrayBuffer)) { + throw new $TypeError('Assertion failed: `arrayBuffer` must be an Object with an [[ArrayBufferData]] internal slot'); + } + + if (!IsDetachedBuffer(arrayBuffer)) { // node v21.0.0+ throws when you structuredClone a detached buffer + if (typeof structuredClone === 'function') { + structuredClone(arrayBuffer, { transfer: [arrayBuffer] }); + } else if (typeof postMessage === 'function') { + postMessage('', '/', [arrayBuffer]); // TODO: see if this might trigger listeners + } else if (MessageChannel) { + (new MessageChannel()).port1.postMessage(null, [arrayBuffer]); + } else { + throw new $SyntaxError('DetachArrayBuffer is not supported in this environment'); + } + } + + return null; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/EnumerableOwnNames.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/EnumerableOwnNames.js new file mode 100644 index 0000000000000000000000000000000000000000..aaac4bbef6da25ac79c7a0836544b768decd8de7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/EnumerableOwnNames.js @@ -0,0 +1,16 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var keys = require('object-keys'); + +// https://262.ecma-international.org/6.0/#sec-enumerableownnames + +module.exports = function EnumerableOwnNames(O) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: Type(O) is not Object'); + } + + return keys(O); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/FromPropertyDescriptor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/FromPropertyDescriptor.js new file mode 100644 index 0000000000000000000000000000000000000000..45b6379f1214c415e1e43b855db01f18b3566cba --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/FromPropertyDescriptor.js @@ -0,0 +1,16 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var isPropertyDescriptor = require('../helpers/records/property-descriptor'); +var fromPropertyDescriptor = require('../helpers/fromPropertyDescriptor'); + +// https://262.ecma-international.org/6.0/#sec-frompropertydescriptor + +module.exports = function FromPropertyDescriptor(Desc) { + if (typeof Desc !== 'undefined' && !isPropertyDescriptor(Desc)) { + throw new $TypeError('Assertion failed: `Desc` must be a Property Descriptor'); + } + + return fromPropertyDescriptor(Desc); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/Get.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/Get.js new file mode 100644 index 0000000000000000000000000000000000000000..42f7a14d853e05735d4166708590df2743cfa74c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/Get.js @@ -0,0 +1,24 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var inspect = require('object-inspect'); + +var isPropertyKey = require('../helpers/isPropertyKey'); + +var isObject = require('es-object-atoms/isObject'); + +// https://262.ecma-international.org/6.0/#sec-get-o-p + +module.exports = function Get(O, P) { + // 7.3.1.1 + if (!isObject(O)) { + throw new $TypeError('Assertion failed: Type(O) is not Object'); + } + // 7.3.1.2 + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: P is not a Property Key, got ' + inspect(P)); + } + // 7.3.1.3 + return O[P]; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/GetGlobalObject.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/GetGlobalObject.js new file mode 100644 index 0000000000000000000000000000000000000000..0541ede0c48889fefe9a137e0e37a2e13573c091 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/GetGlobalObject.js @@ -0,0 +1,9 @@ +'use strict'; + +var getGlobal = require('globalthis/polyfill'); + +// https://262.ecma-international.org/6.0/#sec-getglobalobject + +module.exports = function GetGlobalObject() { + return getGlobal(); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/GetIterator.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/GetIterator.js new file mode 100644 index 0000000000000000000000000000000000000000..1a8d49a686fdb4ae3b9edb87f3dce6a9815565ab --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/GetIterator.js @@ -0,0 +1,30 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var getIteratorMethod = require('../helpers/getIteratorMethod'); +var AdvanceStringIndex = require('./AdvanceStringIndex'); +var Call = require('./Call'); +var GetMethod = require('./GetMethod'); + +var isObject = require('es-object-atoms/isObject'); + +var ES = { + AdvanceStringIndex: AdvanceStringIndex, + GetMethod: GetMethod +}; + +// https://262.ecma-international.org/6.0/#sec-getiterator + +module.exports = function GetIterator(obj, method) { + var actualMethod = method; + if (arguments.length < 2) { + actualMethod = getIteratorMethod(ES, obj); + } + var iterator = Call(actualMethod, obj); + if (!isObject(iterator)) { + throw new $TypeError('iterator must return an object'); + } + + return iterator; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/GetMethod.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/GetMethod.js new file mode 100644 index 0000000000000000000000000000000000000000..e28bb1501fc8e4d4a67250c5110cba73bbcba385 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/GetMethod.js @@ -0,0 +1,34 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var GetV = require('./GetV'); +var IsCallable = require('./IsCallable'); +var isPropertyKey = require('../helpers/isPropertyKey'); + +var inspect = require('object-inspect'); + +// https://262.ecma-international.org/6.0/#sec-getmethod + +module.exports = function GetMethod(O, P) { + // 7.3.9.1 + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: P is not a Property Key'); + } + + // 7.3.9.2 + var func = GetV(O, P); + + // 7.3.9.4 + if (func == null) { + return void 0; + } + + // 7.3.9.5 + if (!IsCallable(func)) { + throw new $TypeError(inspect(P) + ' is not a function: ' + inspect(func)); + } + + // 7.3.9.6 + return func; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/GetOwnPropertyKeys.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/GetOwnPropertyKeys.js new file mode 100644 index 0000000000000000000000000000000000000000..e9b50d744a5fdf42221ad18e6674e777fa3b0a47 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/GetOwnPropertyKeys.js @@ -0,0 +1,30 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var hasSymbols = require('has-symbols')(); + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var $gOPN = GetIntrinsic('%Object.getOwnPropertyNames%', true); +var $gOPS = hasSymbols && GetIntrinsic('%Object.getOwnPropertySymbols%', true); +var keys = require('object-keys'); + +// https://262.ecma-international.org/6.0/#sec-getownpropertykeys + +module.exports = function GetOwnPropertyKeys(O, Type) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: Type(O) is not Object'); + } + if (Type === 'Symbol') { + return $gOPS ? $gOPS(O) : []; + } + if (Type === 'String') { + if (!$gOPN) { + return keys(O); + } + return $gOPN(O); + } + throw new $TypeError('Assertion failed: `Type` must be `"String"` or `"Symbol"`'); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/GetPrototypeFromConstructor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/GetPrototypeFromConstructor.js new file mode 100644 index 0000000000000000000000000000000000000000..687f6ef200fb11a3dc97a27533d15430c305fb3b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/GetPrototypeFromConstructor.js @@ -0,0 +1,33 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $Function = GetIntrinsic('%Function%'); +var $TypeError = require('es-errors/type'); +var $SyntaxError = require('es-errors/syntax'); + +var Get = require('./Get'); +var IsConstructor = require('./IsConstructor'); + +var isObject = require('es-object-atoms/isObject'); + +// https://262.ecma-international.org/6.0/#sec-getprototypefromconstructor + +module.exports = function GetPrototypeFromConstructor(constructor, intrinsicDefaultProto) { + var intrinsic = GetIntrinsic(intrinsicDefaultProto); // throws if not a valid intrinsic + if (!isObject(intrinsic)) { + throw new $TypeError('intrinsicDefaultProto must be an object'); + } + if (!IsConstructor(constructor)) { + throw new $TypeError('Assertion failed: `constructor` must be a constructor'); + } + var proto = Get(constructor, 'prototype'); + if (!isObject(proto)) { + if (!(constructor instanceof $Function)) { + // ignore other realms, for now + throw new $SyntaxError('cross-realm constructors not currently supported'); + } + proto = intrinsic; + } + return proto; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/GetSubstitution.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/GetSubstitution.js new file mode 100644 index 0000000000000000000000000000000000000000..13cd94ad863d4ae766025ebc687bd6628666e637 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/GetSubstitution.js @@ -0,0 +1,98 @@ + +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $TypeError = require('es-errors/type'); +var $parseInt = GetIntrinsic('%parseInt%'); + +var inspect = require('object-inspect'); +var isInteger = require('math-intrinsics/isInteger'); +var regexTester = require('safe-regex-test'); +var callBound = require('call-bound'); +var every = require('../helpers/every'); + +var isDigit = regexTester(/^[0-9]$/); + +var $charAt = callBound('String.prototype.charAt'); +var $strSlice = callBound('String.prototype.slice'); + +var IsArray = require('./IsArray'); + +var isStringOrUndefined = require('../helpers/isStringOrUndefined'); + +// https://262.ecma-international.org/6.0/#sec-getsubstitution + +// eslint-disable-next-line max-statements, max-lines-per-function +module.exports = function GetSubstitution(matched, str, position, captures, replacement) { + if (typeof matched !== 'string') { + throw new $TypeError('Assertion failed: `matched` must be a String'); + } + var matchLength = matched.length; + + if (typeof str !== 'string') { + throw new $TypeError('Assertion failed: `str` must be a String'); + } + var stringLength = str.length; + + if (!isInteger(position) || position < 0 || position > stringLength) { + throw new $TypeError('Assertion failed: `position` must be a nonnegative integer, and less than or equal to the length of `string`, got ' + inspect(position)); + } + + if (!IsArray(captures) || !every(captures, isStringOrUndefined)) { + throw new $TypeError('Assertion failed: `captures` must be a List of Strings, got ' + inspect(captures)); + } + + if (typeof replacement !== 'string') { + throw new $TypeError('Assertion failed: `replacement` must be a String'); + } + + var tailPos = position + matchLength; + var m = captures.length; + + var result = ''; + for (var i = 0; i < replacement.length; i += 1) { + // if this is a $, and it's not the end of the replacement + var current = $charAt(replacement, i); + var isLast = (i + 1) >= replacement.length; + var nextIsLast = (i + 2) >= replacement.length; + if (current === '$' && !isLast) { + var next = $charAt(replacement, i + 1); + if (next === '$') { + result += '$'; + i += 1; + } else if (next === '&') { + result += matched; + i += 1; + } else if (next === '`') { + result += position === 0 ? '' : $strSlice(str, 0, position - 1); + i += 1; + } else if (next === "'") { + result += tailPos >= stringLength ? '' : $strSlice(str, tailPos); + i += 1; + } else { + var nextNext = nextIsLast ? null : $charAt(replacement, i + 2); + if (isDigit(next) && next !== '0' && (nextIsLast || !isDigit(nextNext))) { + // $1 through $9, and not followed by a digit + var n = $parseInt(next, 10); + // if (n > m, impl-defined) + result += n <= m && typeof captures[n - 1] === 'undefined' ? '' : captures[n - 1]; + i += 1; + } else if (isDigit(next) && (nextIsLast || isDigit(nextNext))) { + // $00 through $99 + var nn = next + nextNext; + var nnI = $parseInt(nn, 10) - 1; + // if nn === '00' or nn > m, impl-defined + result += nn <= m && typeof captures[nnI] === 'undefined' ? '' : captures[nnI]; + i += 2; + } else { + result += '$'; + } + } + } else { + // the final $, or else not a $ + result += $charAt(replacement, i); + } + } + return result; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/GetV.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/GetV.js new file mode 100644 index 0000000000000000000000000000000000000000..920dec3c4a4eac8aa63678c2afa5683e79e3337f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/GetV.js @@ -0,0 +1,23 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var inspect = require('object-inspect'); + +var isPropertyKey = require('../helpers/isPropertyKey'); +// var ToObject = require('./ToObject'); + +// https://262.ecma-international.org/6.0/#sec-getv + +module.exports = function GetV(V, P) { + // 7.3.2.1 + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: P is not a Property Key, got ' + inspect(P)); + } + + // 7.3.2.2-3 + // var O = ToObject(V); + + // 7.3.2.4 + return V[P]; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/GetValueFromBuffer.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/GetValueFromBuffer.js new file mode 100644 index 0000000000000000000000000000000000000000..893929edbc56f4d6b6340295f91e2d24cc82ad4c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/GetValueFromBuffer.js @@ -0,0 +1,86 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $TypeError = require('es-errors/type'); +var $Uint8Array = GetIntrinsic('%Uint8Array%', true); + +var isInteger = require('math-intrinsics/isInteger'); +var callBound = require('call-bound'); + +var $charAt = callBound('String.prototype.charAt'); +var $reverse = callBound('Array.prototype.reverse'); +var $slice = callBound('Array.prototype.slice'); + +var bytesAsFloat32 = require('../helpers/bytesAsFloat32'); +var bytesAsFloat64 = require('../helpers/bytesAsFloat64'); +var bytesAsInteger = require('../helpers/bytesAsInteger'); +var defaultEndianness = require('../helpers/defaultEndianness'); + +var IsDetachedBuffer = require('./IsDetachedBuffer'); + +var isArrayBuffer = require('is-array-buffer'); +var safeConcat = require('safe-array-concat'); + +var tableTAO = require('./tables/typed-array-objects'); + +var isUnsignedElementType = function isUnsignedElementType(type) { return $charAt(type, 0) === 'U'; }; + +// https://262.ecma-international.org/6.0/#sec-getvaluefrombuffer + +module.exports = function GetValueFromBuffer(arrayBuffer, byteIndex, type) { + if (!isArrayBuffer(arrayBuffer)) { + throw new $TypeError('Assertion failed: `arrayBuffer` must be an ArrayBuffer'); + } + + if (!isInteger(byteIndex)) { + throw new $TypeError('Assertion failed: `byteIndex` must be an integer'); + } + + if (typeof type !== 'string') { + throw new $TypeError('Assertion failed: `type` must be a string'); + } + + if (arguments.length > 3 && typeof arguments[3] !== 'boolean') { + throw new $TypeError('Assertion failed: `isLittleEndian` must be a boolean, if present'); + } + + if (IsDetachedBuffer(arrayBuffer)) { + throw new $TypeError('Assertion failed: ArrayBuffer is detached'); // step 1 + } + + // 2. Assert: There are sufficient bytes in arrayBuffer starting at byteIndex to represent a value of type. + + if (byteIndex < 0) { + throw new $TypeError('Assertion failed: `byteIndex` must be non-negative'); // step 3 + } + + // 4. Let block be arrayBuffer’s [[ArrayBufferData]] internal slot. + + var elementSize = tableTAO.size['$' + type]; // step 5 + if (!elementSize) { + throw new $TypeError('Assertion failed: `type` must be one of ' + tableTAO.choices); + } + + // 6. Let rawValue be a List of elementSize containing, in order, the elementSize sequence of bytes starting with block[byteIndex]. + var rawValue = $slice(new $Uint8Array(arrayBuffer, byteIndex), 0, elementSize); // step 6 + + // 8. If isLittleEndian is not present, set isLittleEndian to either true or false. The choice is implementation dependent and should be the alternative that is most efficient for the implementation. An implementation must use the same value each time this step is executed and the same value must be used for the corresponding step in the SetValueInBuffer abstract operation. + var isLittleEndian = arguments.length > 3 ? arguments[3] : defaultEndianness === 'little'; // step 7 + + if (!isLittleEndian) { + $reverse(rawValue); // step 8 + } + + var bytes = $slice(safeConcat([0, 0, 0, 0, 0, 0, 0, 0], rawValue), -elementSize); + + if (type === 'Float32') { // step 3 + return bytesAsFloat32(bytes); + } + + if (type === 'Float64') { // step 4 + return bytesAsFloat64(bytes); + } + + return bytesAsInteger(bytes, elementSize, isUnsignedElementType(type), false); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/HasOwnProperty.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/HasOwnProperty.js new file mode 100644 index 0000000000000000000000000000000000000000..617f0b856e81f2518d2c03bf72b367eea50eb6ef --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/HasOwnProperty.js @@ -0,0 +1,20 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var hasOwn = require('hasown'); +var isObject = require('es-object-atoms/isObject'); + +var isPropertyKey = require('../helpers/isPropertyKey'); + +// https://262.ecma-international.org/6.0/#sec-hasownproperty + +module.exports = function HasOwnProperty(O, P) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: `O` must be an Object'); + } + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: `P` must be a Property Key'); + } + return hasOwn(O, P); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/HasProperty.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/HasProperty.js new file mode 100644 index 0000000000000000000000000000000000000000..eb66ca9853ec09c092d87f10333fcdb19a882c83 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/HasProperty.js @@ -0,0 +1,18 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var isPropertyKey = require('../helpers/isPropertyKey'); + +// https://262.ecma-international.org/6.0/#sec-hasproperty + +module.exports = function HasProperty(O, P) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: `O` must be an Object'); + } + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: `P` must be a Property Key'); + } + return P in O; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/HourFromTime.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/HourFromTime.js new file mode 100644 index 0000000000000000000000000000000000000000..f963bfb68540ba21f46be00b623cb89db98d63f5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/HourFromTime.js @@ -0,0 +1,14 @@ +'use strict'; + +var floor = require('./floor'); +var modulo = require('./modulo'); + +var timeConstants = require('../helpers/timeConstants'); +var msPerHour = timeConstants.msPerHour; +var HoursPerDay = timeConstants.HoursPerDay; + +// https://262.ecma-international.org/5.1/#sec-15.9.1.10 + +module.exports = function HourFromTime(t) { + return modulo(floor(t / msPerHour), HoursPerDay); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/InLeapYear.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/InLeapYear.js new file mode 100644 index 0000000000000000000000000000000000000000..4a283a4b6097f4b2c4e872b0cc775024ff517b77 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/InLeapYear.js @@ -0,0 +1,19 @@ +'use strict'; + +var $EvalError = require('es-errors/eval'); + +var DaysInYear = require('./DaysInYear'); +var YearFromTime = require('./YearFromTime'); + +// https://262.ecma-international.org/5.1/#sec-15.9.1.3 + +module.exports = function InLeapYear(t) { + var days = DaysInYear(YearFromTime(t)); + if (days === 365) { + return 0; + } + if (days === 366) { + return 1; + } + throw new $EvalError('Assertion failed: there are not 365 or 366 days in a year, got: ' + days); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/InstanceofOperator.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/InstanceofOperator.js new file mode 100644 index 0000000000000000000000000000000000000000..5dd7d04a4c16b423b1613070585b864e22b2dc9e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/InstanceofOperator.js @@ -0,0 +1,30 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var $hasInstance = GetIntrinsic('%Symbol.hasInstance%', true); + +var Call = require('./Call'); +var GetMethod = require('./GetMethod'); +var IsCallable = require('./IsCallable'); +var OrdinaryHasInstance = require('./OrdinaryHasInstance'); +var ToBoolean = require('./ToBoolean'); + +// https://262.ecma-international.org/6.0/#sec-instanceofoperator + +module.exports = function InstanceofOperator(O, C) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: Type(O) is not Object'); + } + var instOfHandler = $hasInstance ? GetMethod(C, $hasInstance) : void 0; + if (typeof instOfHandler !== 'undefined') { + return ToBoolean(Call(instOfHandler, C, [O])); + } + if (!IsCallable(C)) { + throw new $TypeError('`C` is not Callable'); + } + return OrdinaryHasInstance(C, O); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IntegerIndexedElementGet.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IntegerIndexedElementGet.js new file mode 100644 index 0000000000000000000000000000000000000000..796ea2c3d5038fbe6080ad123426eeb585917fab --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IntegerIndexedElementGet.js @@ -0,0 +1,57 @@ +'use strict'; + +var $SyntaxError = require('es-errors/syntax'); +var $TypeError = require('es-errors/type'); +var isNegativeZero = require('math-intrinsics/isNegativeZero'); + +var GetValueFromBuffer = require('./GetValueFromBuffer'); +var IsDetachedBuffer = require('./IsDetachedBuffer'); +var IsInteger = require('./IsInteger'); + +var typedArrayLength = require('typed-array-length'); +var typedArrayBuffer = require('typed-array-buffer'); +var typedArrayByteOffset = require('typed-array-byte-offset'); +var whichTypedArray = require('which-typed-array'); + +var tableTAO = require('./tables/typed-array-objects'); + +// https://262.ecma-international.org/6.0/#sec-integerindexedelementget + +module.exports = function IntegerIndexedElementGet(O, index) { + if (typeof index !== 'number') { + throw new $TypeError('`index` must be a Number'); // step 1 + } + var arrayTypeName = whichTypedArray(O); // step 10 + if (!arrayTypeName) { + throw new $TypeError('`O` must be a TypedArray'); // step 2 + } + if (arrayTypeName === 'BigInt64Array' || arrayTypeName === 'BigUint64Array') { + throw new $SyntaxError('BigInt64Array and BigUint64Array do not exist until ES2020'); + } + + var buffer = typedArrayBuffer(O); // step 3 + + if (IsDetachedBuffer(buffer)) { + throw new $TypeError('`O` has a detached buffer'); // step 4 + } + + if (!IsInteger(index) || isNegativeZero(index)) { + return void undefined; // steps 5 - 6 + } + + var length = typedArrayLength(O); // step 7 + + if (index < 0 || index >= length) { + return void undefined; // step 8 + } + + var offset = typedArrayByteOffset(O); // step 9 + + var elementType = tableTAO.name['$' + arrayTypeName]; // step 13 + + var elementSize = tableTAO.size['$' + elementType]; // step 11 + + var indexedPosition = (index * elementSize) + offset; // step 12 + + return GetValueFromBuffer(buffer, indexedPosition, elementType); // step 14 +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IntegerIndexedElementSet.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IntegerIndexedElementSet.js new file mode 100644 index 0000000000000000000000000000000000000000..908e0a979ad5cf50cb02afa2e35f6cf807884319 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IntegerIndexedElementSet.js @@ -0,0 +1,62 @@ +'use strict'; + +var $SyntaxError = require('es-errors/syntax'); +var $TypeError = require('es-errors/type'); + +var IsDetachedBuffer = require('./IsDetachedBuffer'); +var IsInteger = require('./IsInteger'); +var SetValueInBuffer = require('./SetValueInBuffer'); +var ToNumber = require('./ToNumber'); + +var isNegativeZero = require('math-intrinsics/isNegativeZero'); +var typedArrayBuffer = require('typed-array-buffer'); +var typedArrayByteOffset = require('typed-array-byte-offset'); +var typedArrayLength = require('typed-array-length'); +var whichTypedArray = require('which-typed-array'); + +var tableTAO = require('./tables/typed-array-objects'); + +// https://262.ecma-international.org/6.0/#sec-integerindexedelementset + +module.exports = function IntegerIndexedElementSet(O, index, value) { + if (typeof index !== 'number') { + throw new $TypeError('`index` must be a Number'); // step 1 + } + var arrayTypeName = whichTypedArray(O); // step 12 + if (!arrayTypeName) { + throw new $TypeError('`O` must be a TypedArray'); // step 2 + } + if (arrayTypeName === 'BigInt64Array' || arrayTypeName === 'BigUint64Array') { + throw new $SyntaxError('BigInt64Array and BigUint64Array do not exist until ES2020'); // step 2 + } + + var numValue = ToNumber(value); // step 3 + + var buffer = typedArrayBuffer(O); // step 5 + + if (IsDetachedBuffer(buffer)) { + throw new $TypeError('`O` has a detached buffer'); // step 6 + } + + if (!IsInteger(index) || isNegativeZero(index)) { + return false; // steps 7 - 8 + } + + var length = typedArrayLength(O); // step 9 + + if (index < 0 || index >= length) { + return false; // step 10 + } + + var offset = typedArrayByteOffset(O); // step 11 + + var elementType = tableTAO.name['$' + arrayTypeName]; // step 15 + + var elementSize = tableTAO.size['$' + elementType]; // step 13 + + var indexedPosition = (index * elementSize) + offset; // step 14 + + SetValueInBuffer(buffer, indexedPosition, elementType, numValue); // step 16 + + return true; // step 17 +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/InternalizeJSONProperty.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/InternalizeJSONProperty.js new file mode 100644 index 0000000000000000000000000000000000000000..6471a609d9770a8ad7d09b98b2ed7125d60a0c75 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/InternalizeJSONProperty.js @@ -0,0 +1,68 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var Call = require('./Call'); +var CreateDataProperty = require('./CreateDataProperty'); +var EnumerableOwnNames = require('./EnumerableOwnNames'); +var Get = require('./Get'); +var IsArray = require('./IsArray'); +var ToLength = require('./ToLength'); +var ToString = require('./ToString'); + +var forEach = require('../helpers/forEach'); + +// https://262.ecma-international.org/6.0/#sec-internalizejsonproperty + +// note: `reviver` was implicitly closed-over until ES2020, where it becomes a third argument + +module.exports = function InternalizeJSONProperty(holder, name, reviver) { + if (!isObject(holder)) { + throw new $TypeError('Assertion failed: `holder` is not an Object'); + } + if (typeof name !== 'string') { + throw new $TypeError('Assertion failed: `name` is not a String'); + } + if (typeof reviver !== 'function') { + throw new $TypeError('Assertion failed: `reviver` is not a Function'); + } + + var val = Get(holder, name); // step 1 + + if (isObject(val)) { // step 3 + var isArray = IsArray(val); // step 3.a + if (isArray) { // step 3.c + var I = 0; // step 3.c.i + + var len = ToLength(Get(val, 'length')); // step 3.b.ii + + while (I < len) { // step 3.b.iv + var newElement = InternalizeJSONProperty(val, ToString(I), reviver); // step 3.b.iv.1 + + if (typeof newElement === 'undefined') { // step 3.b.iv.3 + delete val[ToString(I)]; // step 3.b.iv.3.a + } else { // step 3.b.iv.4 + CreateDataProperty(val, ToString(I), newElement); // step 3.b.iv.4.a + } + + I += 1; // step 3.b.iv.6 + } + } else { + var keys = EnumerableOwnNames(val); // step 3.d.i + + forEach(keys, function (P) { // step 3.d.iii + // eslint-disable-next-line no-shadow + var newElement = InternalizeJSONProperty(val, P, reviver); // step 3.d.iii.1 + + if (typeof newElement === 'undefined') { // step 3.d.iii.3 + delete val[P]; // step 3.d.iii.3.a + } else { // step 3.d.iii.4 + CreateDataProperty(val, P, newElement); // step 3.d.iii.4.a + } + }); + } + } + + return Call(reviver, holder, [name, val]); // step 4 +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/Invoke.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/Invoke.js new file mode 100644 index 0000000000000000000000000000000000000000..57bca8ebc3dcb6172949cb3bef6f134dacabbf4b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/Invoke.js @@ -0,0 +1,22 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var Call = require('./Call'); +var IsArray = require('./IsArray'); +var GetV = require('./GetV'); +var isPropertyKey = require('../helpers/isPropertyKey'); + +// https://262.ecma-international.org/6.0/#sec-invoke + +module.exports = function Invoke(O, P) { + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: P must be a Property Key'); + } + var argumentsList = arguments.length > 2 ? arguments[2] : []; + if (!IsArray(argumentsList)) { + throw new $TypeError('Assertion failed: optional `argumentsList`, if provided, must be a List'); + } + var func = GetV(O, P); + return Call(func, O, argumentsList); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsAccessorDescriptor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsAccessorDescriptor.js new file mode 100644 index 0000000000000000000000000000000000000000..f7bf73afb1c1617b04596a6e2af6d1617857bf1e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsAccessorDescriptor.js @@ -0,0 +1,25 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var hasOwn = require('hasown'); + +var isPropertyDescriptor = require('../helpers/records/property-descriptor'); + +// https://262.ecma-international.org/5.1/#sec-8.10.1 + +module.exports = function IsAccessorDescriptor(Desc) { + if (typeof Desc === 'undefined') { + return false; + } + + if (!isPropertyDescriptor(Desc)) { + throw new $TypeError('Assertion failed: `Desc` must be a Property Descriptor'); + } + + if (!hasOwn(Desc, '[[Get]]') && !hasOwn(Desc, '[[Set]]')) { + return false; + } + + return true; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsArray.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsArray.js new file mode 100644 index 0000000000000000000000000000000000000000..c2c48c1f233c058c691d45d7587f1b58d3de5eb2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsArray.js @@ -0,0 +1,4 @@ +'use strict'; + +// https://262.ecma-international.org/6.0/#sec-isarray +module.exports = require('../helpers/IsArray'); diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsCallable.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsCallable.js new file mode 100644 index 0000000000000000000000000000000000000000..3a69b19267dff33491a84421b667a0d82cba21f9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsCallable.js @@ -0,0 +1,5 @@ +'use strict'; + +// http://262.ecma-international.org/5.1/#sec-9.11 + +module.exports = require('is-callable'); diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsCompatiblePropertyDescriptor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsCompatiblePropertyDescriptor.js new file mode 100644 index 0000000000000000000000000000000000000000..8bdaf3eb45d24407a2a416cc5aadab4f4eb1c7da --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsCompatiblePropertyDescriptor.js @@ -0,0 +1,9 @@ +'use strict'; + +var ValidateAndApplyPropertyDescriptor = require('./ValidateAndApplyPropertyDescriptor'); + +// https://262.ecma-international.org/6.0/#sec-iscompatiblepropertydescriptor + +module.exports = function IsCompatiblePropertyDescriptor(Extensible, Desc, Current) { + return ValidateAndApplyPropertyDescriptor(undefined, undefined, Extensible, Desc, Current); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsConcatSpreadable.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsConcatSpreadable.js new file mode 100644 index 0000000000000000000000000000000000000000..ace2695309292c91b185505f63da3cc942534bd2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsConcatSpreadable.js @@ -0,0 +1,26 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $isConcatSpreadable = GetIntrinsic('%Symbol.isConcatSpreadable%', true); + +var Get = require('./Get'); +var IsArray = require('./IsArray'); +var ToBoolean = require('./ToBoolean'); + +var isObject = require('es-object-atoms/isObject'); + +// https://262.ecma-international.org/6.0/#sec-isconcatspreadable + +module.exports = function IsConcatSpreadable(O) { + if (!isObject(O)) { + return false; + } + if ($isConcatSpreadable) { + var spreadable = Get(O, $isConcatSpreadable); + if (typeof spreadable !== 'undefined') { + return ToBoolean(spreadable); + } + } + return IsArray(O); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsConstructor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsConstructor.js new file mode 100644 index 0000000000000000000000000000000000000000..62ac47f6a3d262927a9b147ee0057dfba9664b24 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsConstructor.js @@ -0,0 +1,40 @@ +'use strict'; + +var GetIntrinsic = require('../GetIntrinsic.js'); + +var $construct = GetIntrinsic('%Reflect.construct%', true); + +var DefinePropertyOrThrow = require('./DefinePropertyOrThrow'); +try { + DefinePropertyOrThrow({}, '', { '[[Get]]': function () {} }); +} catch (e) { + // Accessor properties aren't supported + DefinePropertyOrThrow = null; +} + +// https://262.ecma-international.org/6.0/#sec-isconstructor + +if (DefinePropertyOrThrow && $construct) { + var isConstructorMarker = {}; + var badArrayLike = {}; + DefinePropertyOrThrow(badArrayLike, 'length', { + '[[Get]]': function () { + throw isConstructorMarker; + }, + '[[Enumerable]]': true + }); + + module.exports = function IsConstructor(argument) { + try { + // `Reflect.construct` invokes `IsConstructor(target)` before `Get(args, 'length')`: + $construct(argument, badArrayLike); + } catch (err) { + return err === isConstructorMarker; + } + }; +} else { + module.exports = function IsConstructor(argument) { + // unfortunately there's no way to truly check this without try/catch `new argument` in old environments + return typeof argument === 'function' && !!argument.prototype; + }; +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsDataDescriptor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsDataDescriptor.js new file mode 100644 index 0000000000000000000000000000000000000000..d56bd36d4294369f6486f6dfc5d60dada2cc410a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsDataDescriptor.js @@ -0,0 +1,25 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var hasOwn = require('hasown'); + +var isPropertyDescriptor = require('../helpers/records/property-descriptor'); + +// https://262.ecma-international.org/5.1/#sec-8.10.2 + +module.exports = function IsDataDescriptor(Desc) { + if (typeof Desc === 'undefined') { + return false; + } + + if (!isPropertyDescriptor(Desc)) { + throw new $TypeError('Assertion failed: `Desc` must be a Property Descriptor'); + } + + if (!hasOwn(Desc, '[[Value]]') && !hasOwn(Desc, '[[Writable]]')) { + return false; + } + + return true; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsDetachedBuffer.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsDetachedBuffer.js new file mode 100644 index 0000000000000000000000000000000000000000..afdc5c8b33948b0c78f8735c8156c81b2adb1102 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsDetachedBuffer.js @@ -0,0 +1,25 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var $byteLength = require('array-buffer-byte-length'); + +var isArrayBuffer = require('is-array-buffer'); + +var availableTypedArrays = require('available-typed-arrays')(); + +// https://262.ecma-international.org/6.0/#sec-isdetachedbuffer + +module.exports = function IsDetachedBuffer(arrayBuffer) { + if (!isArrayBuffer(arrayBuffer)) { + throw new $TypeError('Assertion failed: `arrayBuffer` must be an Object with an [[ArrayBufferData]] internal slot'); + } + if ($byteLength(arrayBuffer) === 0) { + try { + new global[availableTypedArrays[0]](arrayBuffer); // eslint-disable-line no-new + } catch (error) { + return !!error && error.name === 'TypeError'; + } + } + return false; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsExtensible.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsExtensible.js new file mode 100644 index 0000000000000000000000000000000000000000..aa19b914c2d3dc31c1215e2b203dc3ffbb78746c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsExtensible.js @@ -0,0 +1,18 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $preventExtensions = GetIntrinsic('%Object.preventExtensions%', true); +var $isExtensible = GetIntrinsic('%Object.isExtensible%', true); + +var isPrimitive = require('../helpers/isPrimitive'); + +// https://262.ecma-international.org/6.0/#sec-isextensible-o + +module.exports = $preventExtensions + ? function IsExtensible(obj) { + return !isPrimitive(obj) && $isExtensible(obj); + } + : function IsExtensible(obj) { + return !isPrimitive(obj); + }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsGenericDescriptor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsGenericDescriptor.js new file mode 100644 index 0000000000000000000000000000000000000000..9f6ef045ee44e9eaea4506a234f0e41e0bd1bac9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsGenericDescriptor.js @@ -0,0 +1,26 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var IsAccessorDescriptor = require('./IsAccessorDescriptor'); +var IsDataDescriptor = require('./IsDataDescriptor'); + +var isPropertyDescriptor = require('../helpers/records/property-descriptor'); + +// https://262.ecma-international.org/6.0/#sec-isgenericdescriptor + +module.exports = function IsGenericDescriptor(Desc) { + if (typeof Desc === 'undefined') { + return false; + } + + if (!isPropertyDescriptor(Desc)) { + throw new $TypeError('Assertion failed: `Desc` must be a Property Descriptor'); + } + + if (!IsAccessorDescriptor(Desc) && !IsDataDescriptor(Desc)) { + return true; + } + + return false; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsInteger.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsInteger.js new file mode 100644 index 0000000000000000000000000000000000000000..9acd7638f5933240e9211a985556ed27df4e82ad --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsInteger.js @@ -0,0 +1,9 @@ +'use strict'; + +var isInteger = require('math-intrinsics/isInteger'); + +// https://262.ecma-international.org/6.0/#sec-isinteger + +module.exports = function IsInteger(argument) { + return isInteger(argument); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsPromise.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsPromise.js new file mode 100644 index 0000000000000000000000000000000000000000..f3d67b1c7045d7657ec74a6d084dc088aadb5ff4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsPromise.js @@ -0,0 +1,24 @@ +'use strict'; + +var callBound = require('call-bound'); + +var $PromiseThen = callBound('Promise.prototype.then', true); + +var isObject = require('es-object-atoms/isObject'); + +// https://262.ecma-international.org/6.0/#sec-ispromise + +module.exports = function IsPromise(x) { + if (!isObject(x)) { + return false; + } + if (!$PromiseThen) { // Promises are not supported + return false; + } + try { + $PromiseThen(x); // throws if not a promise + } catch (e) { + return false; + } + return true; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsPropertyDescriptor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsPropertyDescriptor.js new file mode 100644 index 0000000000000000000000000000000000000000..d1e21ac0ec943ac40b6eaf9090b079de98feb712 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsPropertyDescriptor.js @@ -0,0 +1,11 @@ +'use strict'; + +// TODO, semver-major: delete this + +var isPropertyDescriptor = require('../helpers/records/property-descriptor'); + +// https://262.ecma-international.org/6.0/#sec-property-descriptor-specification-type + +module.exports = function IsPropertyDescriptor(Desc) { + return isPropertyDescriptor(Desc); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsPropertyKey.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsPropertyKey.js new file mode 100644 index 0000000000000000000000000000000000000000..4b1c9c71461ca474f34b517c0bc04e5d700280f2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsPropertyKey.js @@ -0,0 +1,9 @@ +'use strict'; + +var isPropertyKey = require('../helpers/isPropertyKey'); + +// https://262.ecma-international.org/6.0/#sec-ispropertykey + +module.exports = function IsPropertyKey(argument) { + return isPropertyKey(argument); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsRegExp.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsRegExp.js new file mode 100644 index 0000000000000000000000000000000000000000..8855492d58ded3c061b84be35e962fe32c8de53e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsRegExp.js @@ -0,0 +1,25 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $match = GetIntrinsic('%Symbol.match%', true); + +var hasRegExpMatcher = require('is-regex'); +var isObject = require('es-object-atoms/isObject'); + +var ToBoolean = require('./ToBoolean'); + +// https://262.ecma-international.org/6.0/#sec-isregexp + +module.exports = function IsRegExp(argument) { + if (!isObject(argument)) { + return false; + } + if ($match) { + var isRegExp = argument[$match]; + if (typeof isRegExp !== 'undefined') { + return ToBoolean(isRegExp); + } + } + return hasRegExpMatcher(argument); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsWordChar.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsWordChar.js new file mode 100644 index 0000000000000000000000000000000000000000..d8a3f9781f4af9a7a2ca52474e2294e2252f78aa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IsWordChar.js @@ -0,0 +1,37 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var IsArray = require('./IsArray'); +var IsInteger = require('./IsInteger'); + +var every = require('../helpers/every'); +var regexTester = require('safe-regex-test'); + +var isChar = function isChar(c) { + return typeof c === 'string' && c.length === 1; +}; + +var isWordCharacter = regexTester(/^[a-zA-Z0-9_]$/); + +// https://262.ecma-international.org/6.0/#sec-runtime-semantics-iswordchar-abstract-operation + +// note: prior to ES2023, this AO erroneously omitted the latter of its arguments. +module.exports = function IsWordChar(e, InputLength, Input) { + if (!IsInteger(e)) { + throw new $TypeError('Assertion failed: `e` must be an integer'); + } + if (!IsInteger(InputLength)) { + throw new $TypeError('Assertion failed: `InputLength` must be an integer'); + } + if (!IsArray(Input) || !every(Input, isChar)) { + throw new $TypeError('Assertion failed: `Input` must be a List of characters'); + } + if (e === -1 || e === InputLength) { + return false; // step 1 + } + + var c = Input[e]; // step 2 + + return isWordCharacter(c); // steps 3-4 +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IteratorClose.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IteratorClose.js new file mode 100644 index 0000000000000000000000000000000000000000..e3e51d981459cc3ae61c9555d12914a3898ed467 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IteratorClose.js @@ -0,0 +1,49 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var Call = require('./Call'); +var CompletionRecord = require('./CompletionRecord'); +var GetMethod = require('./GetMethod'); +var IsCallable = require('./IsCallable'); + +// https://262.ecma-international.org/6.0/#sec-iteratorclose + +module.exports = function IteratorClose(iterator, completion) { + if (!isObject(iterator)) { + throw new $TypeError('Assertion failed: Type(iterator) is not Object'); + } + if (!IsCallable(completion) && !(completion instanceof CompletionRecord)) { + throw new $TypeError('Assertion failed: completion is not a thunk representing a Completion Record, nor a Completion Record instance'); + } + var completionThunk = completion instanceof CompletionRecord ? function () { return completion['?'](); } : completion; + + var iteratorReturn = GetMethod(iterator, 'return'); + + if (typeof iteratorReturn === 'undefined') { + return completionThunk(); + } + + var completionRecord; + try { + var innerResult = Call(iteratorReturn, iterator, []); + } catch (e) { + // if we hit here, then "e" is the innerResult completion that needs re-throwing + + // if the completion is of type "throw", this will throw. + completionThunk(); + completionThunk = null; // ensure it's not called twice. + + // if not, then return the innerResult completion + throw e; + } + completionRecord = completionThunk(); // if innerResult worked, then throw if the completion does + completionThunk = null; // ensure it's not called twice. + + if (!isObject(innerResult)) { + throw new $TypeError('iterator .return must return an object'); + } + + return completionRecord; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IteratorComplete.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IteratorComplete.js new file mode 100644 index 0000000000000000000000000000000000000000..c8a0d67c244bbec3d032bb8a4cc5597b7419d97b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IteratorComplete.js @@ -0,0 +1,16 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var Get = require('./Get'); +var ToBoolean = require('./ToBoolean'); + +// https://262.ecma-international.org/6.0/#sec-iteratorcomplete + +module.exports = function IteratorComplete(iterResult) { + if (!isObject(iterResult)) { + throw new $TypeError('Assertion failed: Type(iterResult) is not Object'); + } + return ToBoolean(Get(iterResult, 'done')); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IteratorNext.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IteratorNext.js new file mode 100644 index 0000000000000000000000000000000000000000..b6bd71c68fca61d152bbf420aa5fdfb2feeab854 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IteratorNext.js @@ -0,0 +1,16 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var Invoke = require('./Invoke'); + +// https://262.ecma-international.org/6.0/#sec-iteratornext + +module.exports = function IteratorNext(iterator, value) { + var result = Invoke(iterator, 'next', arguments.length < 2 ? [] : [value]); + if (!isObject(result)) { + throw new $TypeError('iterator next must return an object'); + } + return result; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IteratorStep.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IteratorStep.js new file mode 100644 index 0000000000000000000000000000000000000000..85bcd95c0410f7efd79ae16b91b0a513d404a64a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IteratorStep.js @@ -0,0 +1,13 @@ +'use strict'; + +var IteratorComplete = require('./IteratorComplete'); +var IteratorNext = require('./IteratorNext'); + +// https://262.ecma-international.org/6.0/#sec-iteratorstep + +module.exports = function IteratorStep(iterator) { + var result = IteratorNext(iterator); + var done = IteratorComplete(result); + return done === true ? false : result; +}; + diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IteratorValue.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IteratorValue.js new file mode 100644 index 0000000000000000000000000000000000000000..016ddfbd4f01381dd13487740d6806003449d4b1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/IteratorValue.js @@ -0,0 +1,16 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var Get = require('./Get'); + +// https://262.ecma-international.org/6.0/#sec-iteratorvalue + +module.exports = function IteratorValue(iterResult) { + if (!isObject(iterResult)) { + throw new $TypeError('Assertion failed: Type(iterResult) is not Object'); + } + return Get(iterResult, 'value'); +}; + diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/MakeDate.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/MakeDate.js new file mode 100644 index 0000000000000000000000000000000000000000..3256ae1092afd21a469f4ca086dc028a73ecaa52 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/MakeDate.js @@ -0,0 +1,14 @@ +'use strict'; + +var $isFinite = require('math-intrinsics/isFinite'); + +var msPerDay = require('../helpers/timeConstants').msPerDay; + +// https://262.ecma-international.org/5.1/#sec-15.9.1.13 + +module.exports = function MakeDate(day, time) { + if (!$isFinite(day) || !$isFinite(time)) { + return NaN; + } + return (day * msPerDay) + time; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/MakeDay.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/MakeDay.js new file mode 100644 index 0000000000000000000000000000000000000000..d03d683855826fe3e3889b737b06a08c34ff4442 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/MakeDay.js @@ -0,0 +1,33 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $DateUTC = GetIntrinsic('%Date.UTC%'); + +var $isFinite = require('math-intrinsics/isFinite'); + +var DateFromTime = require('./DateFromTime'); +var Day = require('./Day'); +var floor = require('./floor'); +var modulo = require('./modulo'); +var MonthFromTime = require('./MonthFromTime'); +var ToInteger = require('./ToInteger'); +var YearFromTime = require('./YearFromTime'); + +// https://262.ecma-international.org/5.1/#sec-15.9.1.12 + +module.exports = function MakeDay(year, month, date) { + if (!$isFinite(year) || !$isFinite(month) || !$isFinite(date)) { + return NaN; + } + var y = ToInteger(year); + var m = ToInteger(month); + var dt = ToInteger(date); + var ym = y + floor(m / 12); + var mn = modulo(m, 12); + var t = $DateUTC(ym, mn, 1); + if (YearFromTime(t) !== ym || MonthFromTime(t) !== mn || DateFromTime(t) !== 1) { + return NaN; + } + return Day(t) + dt - 1; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/MakeTime.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/MakeTime.js new file mode 100644 index 0000000000000000000000000000000000000000..94096d6d4ec8833fa6df121cdef28a8da19c150a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/MakeTime.js @@ -0,0 +1,24 @@ +'use strict'; + +var $isFinite = require('math-intrinsics/isFinite'); + +var timeConstants = require('../helpers/timeConstants'); +var msPerSecond = timeConstants.msPerSecond; +var msPerMinute = timeConstants.msPerMinute; +var msPerHour = timeConstants.msPerHour; + +var ToInteger = require('./ToInteger'); + +// https://262.ecma-international.org/5.1/#sec-15.9.1.11 + +module.exports = function MakeTime(hour, min, sec, ms) { + if (!$isFinite(hour) || !$isFinite(min) || !$isFinite(sec) || !$isFinite(ms)) { + return NaN; + } + var h = ToInteger(hour); + var m = ToInteger(min); + var s = ToInteger(sec); + var milli = ToInteger(ms); + var t = (h * msPerHour) + (m * msPerMinute) + (s * msPerSecond) + milli; + return t; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/MinFromTime.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/MinFromTime.js new file mode 100644 index 0000000000000000000000000000000000000000..a0c631d4cc56cb21e15712def6008d5623edd0f9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/MinFromTime.js @@ -0,0 +1,14 @@ +'use strict'; + +var floor = require('./floor'); +var modulo = require('./modulo'); + +var timeConstants = require('../helpers/timeConstants'); +var msPerMinute = timeConstants.msPerMinute; +var MinutesPerHour = timeConstants.MinutesPerHour; + +// https://262.ecma-international.org/5.1/#sec-15.9.1.10 + +module.exports = function MinFromTime(t) { + return modulo(floor(t / msPerMinute), MinutesPerHour); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/MonthFromTime.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/MonthFromTime.js new file mode 100644 index 0000000000000000000000000000000000000000..e551ee2be6da5cc49c7da94be78095c0803c53d9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/MonthFromTime.js @@ -0,0 +1,51 @@ +'use strict'; + +var $RangeError = require('es-errors/range'); + +var DayWithinYear = require('./DayWithinYear'); +var InLeapYear = require('./InLeapYear'); + +// https://262.ecma-international.org/5.1/#sec-15.9.1.4 + +module.exports = function MonthFromTime(t) { + var day = DayWithinYear(t); + if (0 <= day && day < 31) { + return 0; + } + var leap = InLeapYear(t); + if (31 <= day && day < (59 + leap)) { + return 1; + } + if ((59 + leap) <= day && day < (90 + leap)) { + return 2; + } + if ((90 + leap) <= day && day < (120 + leap)) { + return 3; + } + if ((120 + leap) <= day && day < (151 + leap)) { + return 4; + } + if ((151 + leap) <= day && day < (181 + leap)) { + return 5; + } + if ((181 + leap) <= day && day < (212 + leap)) { + return 6; + } + if ((212 + leap) <= day && day < (243 + leap)) { + return 7; + } + if ((243 + leap) <= day && day < (273 + leap)) { + return 8; + } + if ((273 + leap) <= day && day < (304 + leap)) { + return 9; + } + if ((304 + leap) <= day && day < (334 + leap)) { + return 10; + } + if ((334 + leap) <= day && day < (365 + leap)) { + return 11; + } + + throw new $RangeError('Assertion failed: `day` is out of range'); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/NewPromiseCapability.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/NewPromiseCapability.js new file mode 100644 index 0000000000000000000000000000000000000000..893266fe9f8da7b032d6fc835750a07c30086179 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/NewPromiseCapability.js @@ -0,0 +1,34 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var IsCallable = require('./IsCallable'); +var IsConstructor = require('./IsConstructor'); + +// https://262.ecma-international.org/6.0/#sec-newpromisecapability + +module.exports = function NewPromiseCapability(C) { + if (!IsConstructor(C)) { + throw new $TypeError('C must be a constructor'); // step 1 + } + + var resolvingFunctions = { '[[Resolve]]': void undefined, '[[Reject]]': void undefined }; // step 3 + + var promise = new C(function (resolve, reject) { // steps 4-5 + if (typeof resolvingFunctions['[[Resolve]]'] !== 'undefined' || typeof resolvingFunctions['[[Reject]]'] !== 'undefined') { + throw new $TypeError('executor has already been called'); // step 4.a, 4.b + } + resolvingFunctions['[[Resolve]]'] = resolve; // step 4.c + resolvingFunctions['[[Reject]]'] = reject; // step 4.d + }); // step 4-6 + + if (!IsCallable(resolvingFunctions['[[Resolve]]']) || !IsCallable(resolvingFunctions['[[Reject]]'])) { + throw new $TypeError('executor must provide valid resolve and reject functions'); // steps 7-8 + } + + return { + '[[Promise]]': promise, + '[[Resolve]]': resolvingFunctions['[[Resolve]]'], + '[[Reject]]': resolvingFunctions['[[Reject]]'] + }; // step 9 +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/NormalCompletion.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/NormalCompletion.js new file mode 100644 index 0000000000000000000000000000000000000000..1e429dd65cfaded0bd09155819605198a45c628d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/NormalCompletion.js @@ -0,0 +1,9 @@ +'use strict'; + +var CompletionRecord = require('./CompletionRecord'); + +// https://262.ecma-international.org/6.0/#sec-normalcompletion + +module.exports = function NormalCompletion(value) { + return new CompletionRecord('normal', value); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ObjectCreate.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ObjectCreate.js new file mode 100644 index 0000000000000000000000000000000000000000..c2ef47578051e1b9f051c3daef6a9e0e88055032 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ObjectCreate.js @@ -0,0 +1,50 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $ObjectCreate = GetIntrinsic('%Object.create%', true); +var $TypeError = require('es-errors/type'); +var $SyntaxError = require('es-errors/syntax'); +var isObject = require('es-object-atoms/isObject'); + +var IsArray = require('./IsArray'); + +var forEach = require('../helpers/forEach'); + +var SLOT = require('internal-slot'); + +var hasProto = require('has-proto')(); + +// https://262.ecma-international.org/6.0/#sec-objectcreate + +module.exports = function ObjectCreate(proto, internalSlotsList) { + if (proto !== null && !isObject(proto)) { + throw new $TypeError('Assertion failed: `proto` must be null or an object'); + } + var slots = arguments.length < 2 ? [] : internalSlotsList; // step 1 + if (arguments.length >= 2 && !IsArray(slots)) { + throw new $TypeError('Assertion failed: `internalSlotsList` must be an Array'); + } + + var O; + if (hasProto) { + O = { __proto__: proto }; + } else if ($ObjectCreate) { + O = $ObjectCreate(proto); + } else { + if (proto === null) { + throw new $SyntaxError('native Object.create support is required to create null objects'); + } + var T = function T() {}; + T.prototype = proto; + O = new T(); + } + + if (slots.length > 0) { + forEach(slots, function (slot) { + SLOT.set(O, slot, void undefined); + }); + } + + return O; // step 6 +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ObjectDefineProperties.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ObjectDefineProperties.js new file mode 100644 index 0000000000000000000000000000000000000000..0d41322bcc146b95dea2f81dbb533ed69495414a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ObjectDefineProperties.js @@ -0,0 +1,37 @@ +'use strict'; + +var DefinePropertyOrThrow = require('./DefinePropertyOrThrow'); +var Get = require('./Get'); +var OrdinaryGetOwnProperty = require('./OrdinaryGetOwnProperty'); +var ToObject = require('./ToObject'); +var ToPropertyDescriptor = require('./ToPropertyDescriptor'); + +var forEach = require('../helpers/forEach'); +var OwnPropertyKeys = require('own-keys'); + +// https://262.ecma-international.org/6.0/#sec-objectdefineproperties + +/** @type { = {}>(O: T, Properties: object) => T} */ +module.exports = function ObjectDefineProperties(O, Properties) { + var props = ToObject(Properties); // step 1 + var keys = OwnPropertyKeys(props); // step 2 + /** @type {[string | symbol, import('../types').Descriptor][]} */ + var descriptors = []; // step 3 + + forEach(keys, function (nextKey) { // step 4 + var propDesc = OrdinaryGetOwnProperty(props, nextKey); // ToPropertyDescriptor(getOwnPropertyDescriptor(props, nextKey)); // step 4.a + if (typeof propDesc !== 'undefined' && propDesc['[[Enumerable]]']) { // step 4.b + var descObj = Get(props, nextKey); // step 4.b.i + var desc = ToPropertyDescriptor(descObj); // step 4.b.ii + descriptors[descriptors.length] = [nextKey, desc]; // step 4.b.iii + } + }); + + forEach(descriptors, function (pair) { // step 5 + var P = pair[0]; // step 5.a + var desc = pair[1]; // step 5.b + DefinePropertyOrThrow(O, P, desc); // step 5.c + }); + + return O; // step 6 +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/OrdinaryCreateFromConstructor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/OrdinaryCreateFromConstructor.js new file mode 100644 index 0000000000000000000000000000000000000000..f84b410439c2e3534ec9b5fa619766962cd4264a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/OrdinaryCreateFromConstructor.js @@ -0,0 +1,20 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); +var $TypeError = require('es-errors/type'); + +var GetPrototypeFromConstructor = require('./GetPrototypeFromConstructor'); +var IsArray = require('./IsArray'); +var ObjectCreate = require('./ObjectCreate'); + +// https://262.ecma-international.org/6.0/#sec-ordinarycreatefromconstructor + +module.exports = function OrdinaryCreateFromConstructor(constructor, intrinsicDefaultProto) { + GetIntrinsic(intrinsicDefaultProto); // throws if not a valid intrinsic + var proto = GetPrototypeFromConstructor(constructor, intrinsicDefaultProto); + var slots = arguments.length < 3 ? [] : arguments[2]; + if (!IsArray(slots)) { + throw new $TypeError('Assertion failed: if provided, `internalSlotsList` must be a List'); + } + return ObjectCreate(proto, slots); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/OrdinaryDefineOwnProperty.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/OrdinaryDefineOwnProperty.js new file mode 100644 index 0000000000000000000000000000000000000000..1a61488c6311f778620cdccb377e0b377040b055 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/OrdinaryDefineOwnProperty.js @@ -0,0 +1,54 @@ +'use strict'; + +var $gOPD = require('gopd'); +var $SyntaxError = require('es-errors/syntax'); +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var isPropertyDescriptor = require('../helpers/records/property-descriptor'); + +var IsAccessorDescriptor = require('./IsAccessorDescriptor'); +var IsExtensible = require('./IsExtensible'); +var isPropertyKey = require('../helpers/isPropertyKey'); +var ToPropertyDescriptor = require('./ToPropertyDescriptor'); +var SameValue = require('./SameValue'); +var ValidateAndApplyPropertyDescriptor = require('./ValidateAndApplyPropertyDescriptor'); + +// https://262.ecma-international.org/6.0/#sec-ordinarydefineownproperty + +module.exports = function OrdinaryDefineOwnProperty(O, P, Desc) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: O must be an Object'); + } + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: P must be a Property Key'); + } + if (!isPropertyDescriptor(Desc)) { + throw new $TypeError('Assertion failed: Desc must be a Property Descriptor'); + } + if (!$gOPD) { + // ES3/IE 8 fallback + if (IsAccessorDescriptor(Desc)) { + throw new $SyntaxError('This environment does not support accessor property descriptors.'); + } + var creatingNormalDataProperty = !(P in O) + && Desc['[[Writable]]'] + && Desc['[[Enumerable]]'] + && Desc['[[Configurable]]'] + && '[[Value]]' in Desc; + var settingExistingDataProperty = (P in O) + && (!('[[Configurable]]' in Desc) || Desc['[[Configurable]]']) + && (!('[[Enumerable]]' in Desc) || Desc['[[Enumerable]]']) + && (!('[[Writable]]' in Desc) || Desc['[[Writable]]']) + && '[[Value]]' in Desc; + if (creatingNormalDataProperty || settingExistingDataProperty) { + O[P] = Desc['[[Value]]']; // eslint-disable-line no-param-reassign + return SameValue(O[P], Desc['[[Value]]']); + } + throw new $SyntaxError('This environment does not support defining non-writable, non-enumerable, or non-configurable properties'); + } + var desc = $gOPD(O, P); + var current = desc && ToPropertyDescriptor(desc); + var extensible = IsExtensible(O); + return ValidateAndApplyPropertyDescriptor(O, P, extensible, Desc, current); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/OrdinaryGetOwnProperty.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/OrdinaryGetOwnProperty.js new file mode 100644 index 0000000000000000000000000000000000000000..fdf6cc0cad72a7d2af37ee6eb9db36cffde6b822 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/OrdinaryGetOwnProperty.js @@ -0,0 +1,40 @@ +'use strict'; + +var $gOPD = require('gopd'); +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); +var hasOwn = require('hasown'); +var callBound = require('call-bound'); + +var $isEnumerable = callBound('Object.prototype.propertyIsEnumerable'); + +var IsArray = require('./IsArray'); +var isPropertyKey = require('../helpers/isPropertyKey'); +var IsRegExp = require('./IsRegExp'); +var ToPropertyDescriptor = require('./ToPropertyDescriptor'); + +// https://262.ecma-international.org/6.0/#sec-ordinarygetownproperty + +module.exports = function OrdinaryGetOwnProperty(O, P) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: O must be an Object'); + } + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: P must be a Property Key'); + } + if (!hasOwn(O, P)) { + return void 0; + } + if (!$gOPD) { + // ES3 / IE 8 fallback + var arrayLength = IsArray(O) && P === 'length'; + var regexLastIndex = IsRegExp(O) && P === 'lastIndex'; + return { + '[[Configurable]]': !(arrayLength || regexLastIndex), + '[[Enumerable]]': $isEnumerable(O, P), + '[[Value]]': O[P], + '[[Writable]]': true + }; + } + return ToPropertyDescriptor($gOPD(O, P)); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/OrdinaryHasInstance.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/OrdinaryHasInstance.js new file mode 100644 index 0000000000000000000000000000000000000000..a0a83e6733a49e898d0f9db5df20a54028ad69e3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/OrdinaryHasInstance.js @@ -0,0 +1,23 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var Get = require('./Get'); +var IsCallable = require('./IsCallable'); + +// https://262.ecma-international.org/6.0/#sec-ordinaryhasinstance + +module.exports = function OrdinaryHasInstance(C, O) { + if (!IsCallable(C)) { + return false; + } + if (!isObject(O)) { + return false; + } + var P = Get(C, 'prototype'); + if (!isObject(P)) { + throw new $TypeError('OrdinaryHasInstance called on an object with an invalid prototype property.'); + } + return O instanceof C; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/OrdinaryHasProperty.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/OrdinaryHasProperty.js new file mode 100644 index 0000000000000000000000000000000000000000..c6c5c11961374a2c3c4beb751aca52a9973093d6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/OrdinaryHasProperty.js @@ -0,0 +1,18 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var isPropertyKey = require('../helpers/isPropertyKey'); + +// https://262.ecma-international.org/6.0/#sec-ordinaryhasproperty + +module.exports = function OrdinaryHasProperty(O, P) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: Type(O) is not Object'); + } + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: P must be a Property Key'); + } + return P in O; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/QuoteJSONString.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/QuoteJSONString.js new file mode 100644 index 0000000000000000000000000000000000000000..616304b82562a0bf5392caf1e0b5bde489dcd7ee --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/QuoteJSONString.js @@ -0,0 +1,48 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var callBound = require('call-bound'); +var forEach = require('../helpers/forEach'); + +var $charCodeAt = callBound('String.prototype.charCodeAt'); +var $numberToString = callBound('Number.prototype.toString'); +var $toLowerCase = callBound('String.prototype.toLowerCase'); +var $strSlice = callBound('String.prototype.slice'); +var $strSplit = callBound('String.prototype.split'); + +// https://262.ecma-international.org/6.0/#sec-quotejsonstring + +var escapes = { + '\u0008': 'b', + '\u000C': 'f', + '\u000A': 'n', + '\u000D': 'r', + '\u0009': 't' +}; + +module.exports = function QuoteJSONString(value) { + if (typeof value !== 'string') { + throw new $TypeError('Assertion failed: `value` must be a String'); + } + var product = '"'; + if (value) { + forEach($strSplit(value, ''), function (C) { + if (C === '"' || C === '\\') { + product += '\u005C' + C; + } else if (C === '\u0008' || C === '\u000C' || C === '\u000A' || C === '\u000D' || C === '\u0009') { + var abbrev = escapes[C]; + product += '\u005C' + abbrev; + } else { + var cCharCode = $charCodeAt(C, 0); + if (cCharCode < 0x20) { + product += '\u005Cu' + $toLowerCase($strSlice('0000' + $numberToString(cCharCode, 16), -4)); + } else { + product += C; + } + } + }); + } + product += '"'; + return product; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/RegExpCreate.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/RegExpCreate.js new file mode 100644 index 0000000000000000000000000000000000000000..68e31605ed1764b9e1addddc5b910e9c9d73fba2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/RegExpCreate.js @@ -0,0 +1,21 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $RegExp = GetIntrinsic('%RegExp%'); + +// var RegExpAlloc = require('./RegExpAlloc'); +// var RegExpInitialize = require('./RegExpInitialize'); +var ToString = require('./ToString'); + +// https://262.ecma-international.org/6.0/#sec-regexpcreate + +module.exports = function RegExpCreate(P, F) { + // var obj = RegExpAlloc($RegExp); + // return RegExpInitialize(obj, P, F); + + // covers spec mechanics; bypass regex brand checking + var pattern = typeof P === 'undefined' ? '' : ToString(P); + var flags = typeof F === 'undefined' ? '' : ToString(F); + return new $RegExp(pattern, flags); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/RegExpExec.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/RegExpExec.js new file mode 100644 index 0000000000000000000000000000000000000000..15762b8343aa380c2c90257eef552a87c56745ae --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/RegExpExec.js @@ -0,0 +1,29 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); +var regexExec = require('call-bound')('RegExp.prototype.exec'); + +var Call = require('./Call'); +var Get = require('./Get'); +var IsCallable = require('./IsCallable'); + +// https://262.ecma-international.org/6.0/#sec-regexpexec + +module.exports = function RegExpExec(R, S) { + if (!isObject(R)) { + throw new $TypeError('Assertion failed: `R` must be an Object'); + } + if (typeof S !== 'string') { + throw new $TypeError('Assertion failed: `S` must be a String'); + } + var exec = Get(R, 'exec'); + if (IsCallable(exec)) { + var result = Call(exec, R, [S]); + if (result === null || isObject(result)) { + return result; + } + throw new $TypeError('"exec" method must return `null` or an Object'); + } + return regexExec(R, S); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/RequireObjectCoercible.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/RequireObjectCoercible.js new file mode 100644 index 0000000000000000000000000000000000000000..b816d1f34b01a80352e783672836a17c49cc06f0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/RequireObjectCoercible.js @@ -0,0 +1,3 @@ +'use strict'; + +module.exports = require('es-object-atoms/RequireObjectCoercible'); diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/SameValue.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/SameValue.js new file mode 100644 index 0000000000000000000000000000000000000000..d07bbb8a8f3fec5ad22ffdfb617245331fcff412 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/SameValue.js @@ -0,0 +1,13 @@ +'use strict'; + +var $isNaN = require('math-intrinsics/isNaN'); + +// http://262.ecma-international.org/5.1/#sec-9.12 + +module.exports = function SameValue(x, y) { + if (x === y) { // 0 === -0, but they are not identical. + if (x === 0) { return 1 / x === 1 / y; } + return true; + } + return $isNaN(x) && $isNaN(y); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/SameValueZero.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/SameValueZero.js new file mode 100644 index 0000000000000000000000000000000000000000..8880e915941eeae2d890f2bdeb1bd057516e3d50 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/SameValueZero.js @@ -0,0 +1,9 @@ +'use strict'; + +var $isNaN = require('math-intrinsics/isNaN'); + +// https://262.ecma-international.org/6.0/#sec-samevaluezero + +module.exports = function SameValueZero(x, y) { + return (x === y) || ($isNaN(x) && $isNaN(y)); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/SecFromTime.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/SecFromTime.js new file mode 100644 index 0000000000000000000000000000000000000000..fc2e44560240f134cf345e63ab69d5f8a2d8cec1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/SecFromTime.js @@ -0,0 +1,14 @@ +'use strict'; + +var floor = require('./floor'); +var modulo = require('./modulo'); + +var timeConstants = require('../helpers/timeConstants'); +var msPerSecond = timeConstants.msPerSecond; +var SecondsPerMinute = timeConstants.SecondsPerMinute; + +// https://262.ecma-international.org/5.1/#sec-15.9.1.10 + +module.exports = function SecFromTime(t) { + return modulo(floor(t / msPerSecond), SecondsPerMinute); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/Set.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/Set.js new file mode 100644 index 0000000000000000000000000000000000000000..f814076a8fb813648eb16093fe86a46182c0fccf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/Set.js @@ -0,0 +1,45 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var isPropertyKey = require('../helpers/isPropertyKey'); +var SameValue = require('./SameValue'); + +// IE 9 does not throw in strict mode when writability/configurability/extensibility is violated +var noThrowOnStrictViolation = (function () { + try { + delete [].length; + return true; + } catch (e) { + return false; + } +}()); + +// https://262.ecma-international.org/6.0/#sec-set-o-p-v-throw + +module.exports = function Set(O, P, V, Throw) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: `O` must be an Object'); + } + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: `P` must be a Property Key'); + } + if (typeof Throw !== 'boolean') { + throw new $TypeError('Assertion failed: `Throw` must be a Boolean'); + } + if (Throw) { + O[P] = V; // eslint-disable-line no-param-reassign + if (noThrowOnStrictViolation && !SameValue(O[P], V)) { + throw new $TypeError('Attempted to assign to readonly property.'); + } + return true; + } + try { + O[P] = V; // eslint-disable-line no-param-reassign + return noThrowOnStrictViolation ? SameValue(O[P], V) : true; + } catch (e) { + return false; + } + +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/SetFunctionName.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/SetFunctionName.js new file mode 100644 index 0000000000000000000000000000000000000000..9e8511fd46bc115d0459cc66f44bb6560ba2bc3a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/SetFunctionName.js @@ -0,0 +1,40 @@ +'use strict'; + +var hasOwn = require('hasown'); + +var $TypeError = require('es-errors/type'); + +var getSymbolDescription = require('get-symbol-description'); + +var DefinePropertyOrThrow = require('./DefinePropertyOrThrow'); +var IsExtensible = require('./IsExtensible'); + +// https://262.ecma-international.org/6.0/#sec-setfunctionname + +module.exports = function SetFunctionName(F, name) { + if (typeof F !== 'function') { + throw new $TypeError('Assertion failed: `F` must be a function'); + } + if (!IsExtensible(F) || hasOwn(F, 'name')) { + throw new $TypeError('Assertion failed: `F` must be extensible, and must not have a `name` own property'); + } + if (typeof name !== 'symbol' && typeof name !== 'string') { + throw new $TypeError('Assertion failed: `name` must be a Symbol or a String'); + } + if (typeof name === 'symbol') { + var description = getSymbolDescription(name); + // eslint-disable-next-line no-param-reassign + name = typeof description === 'undefined' ? '' : '[' + description + ']'; + } + if (arguments.length > 2) { + var prefix = arguments[2]; + // eslint-disable-next-line no-param-reassign + name = prefix + ' ' + name; + } + return DefinePropertyOrThrow(F, 'name', { + '[[Value]]': name, + '[[Writable]]': false, + '[[Enumerable]]': false, + '[[Configurable]]': true + }); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/SetIntegrityLevel.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/SetIntegrityLevel.js new file mode 100644 index 0000000000000000000000000000000000000000..ad92fb99b004f2b05e23fa0b2ef45dfc3775025e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/SetIntegrityLevel.js @@ -0,0 +1,57 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $SyntaxError = require('es-errors/syntax'); +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); +var $gOPD = require('gopd'); +var $preventExtensions = GetIntrinsic('%Object.preventExtensions%', true); +var $gOPN = GetIntrinsic('%Object.getOwnPropertyNames%', true); + +var forEach = require('../helpers/forEach'); + +var DefinePropertyOrThrow = require('./DefinePropertyOrThrow'); +var IsAccessorDescriptor = require('./IsAccessorDescriptor'); +var ToPropertyDescriptor = require('./ToPropertyDescriptor'); + +// https://262.ecma-international.org/6.0/#sec-setintegritylevel + +module.exports = function SetIntegrityLevel(O, level) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: Type(O) is not Object'); + } + if (level !== 'sealed' && level !== 'frozen') { + throw new $TypeError('Assertion failed: `level` must be `"sealed"` or `"frozen"`'); + } + if (!$preventExtensions) { + throw new $SyntaxError('SetIntegrityLevel requires native `Object.preventExtensions` support'); + } + var status = $preventExtensions(O); + if (!status) { + return false; + } + if (!$gOPN) { + throw new $SyntaxError('SetIntegrityLevel requires native `Object.getOwnPropertyNames` support'); + } + var theKeys = $gOPN(O); + if (level === 'sealed') { + forEach(theKeys, function (k) { + DefinePropertyOrThrow(O, k, { configurable: false }); + }); + } else if (level === 'frozen') { + forEach(theKeys, function (k) { + var currentDesc = $gOPD(O, k); + if (typeof currentDesc !== 'undefined') { + var desc; + if (IsAccessorDescriptor(ToPropertyDescriptor(currentDesc))) { + desc = { configurable: false }; + } else { + desc = { configurable: false, writable: false }; + } + DefinePropertyOrThrow(O, k, desc); + } + }); + } + return true; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/SetValueInBuffer.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/SetValueInBuffer.js new file mode 100644 index 0000000000000000000000000000000000000000..0efd30163be06cc4a2929ccbd9b104b30b0b14ef --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/SetValueInBuffer.js @@ -0,0 +1,110 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $TypeError = require('es-errors/type'); +var $Uint8Array = GetIntrinsic('%Uint8Array%', true); + +var isInteger = require('math-intrinsics/isInteger'); + +var IsDetachedBuffer = require('./IsDetachedBuffer'); +var ToInt16 = require('./ToInt16'); +var ToInt32 = require('./ToInt32'); +var ToInt8 = require('./ToInt8'); +var ToUint16 = require('./ToUint16'); +var ToUint32 = require('./ToUint32'); +var ToUint8 = require('./ToUint8'); +var ToUint8Clamp = require('./ToUint8Clamp'); + +var isArrayBuffer = require('is-array-buffer'); +var hasOwn = require('hasown'); + +var tableTAO = require('./tables/typed-array-objects'); + +var TypeToAO = { + __proto__: null, + $Int8: ToInt8, + $Uint8: ToUint8, + $Uint8C: ToUint8Clamp, + $Int16: ToInt16, + $Uint16: ToUint16, + $Int32: ToInt32, + $Uint32: ToUint32 +}; + +var defaultEndianness = require('../helpers/defaultEndianness'); +var forEach = require('../helpers/forEach'); +var integerToNBytes = require('../helpers/integerToNBytes'); +var valueToFloat32Bytes = require('../helpers/valueToFloat32Bytes'); +var valueToFloat64Bytes = require('../helpers/valueToFloat64Bytes'); + +// https://262.ecma-international.org/6.0/#sec-setvalueinbuffer + +module.exports = function SetValueInBuffer(arrayBuffer, byteIndex, type, value) { + if (!isArrayBuffer(arrayBuffer)) { + throw new $TypeError('Assertion failed: `arrayBuffer` must be an ArrayBuffer'); + } + + if (!isInteger(byteIndex)) { + throw new $TypeError('Assertion failed: `byteIndex` must be an integer'); + } + + if (typeof type !== 'string' || !hasOwn(tableTAO.size, '$' + type)) { + throw new $TypeError('Assertion failed: `type` must be one of ' + tableTAO.choices); + } + + if (typeof value !== 'number') { + throw new $TypeError('Assertion failed: `value` must be a number'); + } + + if (arguments.length > 4 && typeof arguments[4] !== 'boolean') { + throw new $TypeError('Assertion failed: `isLittleEndian` must be a boolean, if present'); + } + + if (IsDetachedBuffer(arrayBuffer)) { + throw new $TypeError('Assertion failed: ArrayBuffer is detached'); // step 1 + } + + // 2. Assert: There are sufficient bytes in arrayBuffer starting at byteIndex to represent a value of type. + + if (byteIndex < 0) { + throw new $TypeError('Assertion failed: `byteIndex` must be non-negative'); // step 3 + } + + // 4. Assert: Type(value) is Number. + + // 5. Let block be arrayBuffer’s [[ArrayBufferData]] internal slot. + + // 6. Assert: block is not undefined. + + var elementSize = tableTAO.size['$' + type]; // step 7 + if (!elementSize) { + throw new $TypeError('Assertion failed: `type` must be one of ' + tableTAO.choices); + } + + // 8. If isLittleEndian is not present, set isLittleEndian to either true or false. The choice is implementation dependent and should be the alternative that is most efficient for the implementation. An implementation must use the same value each time this step is executed and the same value must be used for the corresponding step in the GetValueFromBuffer abstract operation. + var isLittleEndian = arguments.length > 4 ? arguments[4] : defaultEndianness === 'little'; // step 8 + + var rawBytes; + if (type === 'Float32') { // step 1 + rawBytes = valueToFloat32Bytes(value, isLittleEndian); + } else if (type === 'Float64') { // step 2 + rawBytes = valueToFloat64Bytes(value, isLittleEndian); + } else { + var n = elementSize; // step 3.a + + var convOp = TypeToAO['$' + type]; // step 3.b + + var intValue = convOp(value); // step 3.c + + rawBytes = integerToNBytes(intValue, n, isLittleEndian); // step 3.d, 3.e, 4 + } + + // 12. Store the individual bytes of rawBytes into block, in order, starting at block[byteIndex]. + var arr = new $Uint8Array(arrayBuffer, byteIndex, elementSize); + forEach(rawBytes, function (rawByte, i) { + arr[i] = rawByte; + }); + + // 13. Return NormalCompletion(undefined). +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/SpeciesConstructor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/SpeciesConstructor.js new file mode 100644 index 0000000000000000000000000000000000000000..23e32b443ef3655f56639920d5cf58474500bf67 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/SpeciesConstructor.js @@ -0,0 +1,32 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $species = GetIntrinsic('%Symbol.species%', true); +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var IsConstructor = require('./IsConstructor'); + +// https://262.ecma-international.org/6.0/#sec-speciesconstructor + +module.exports = function SpeciesConstructor(O, defaultConstructor) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: Type(O) is not Object'); + } + var C = O.constructor; + if (typeof C === 'undefined') { + return defaultConstructor; + } + if (!isObject(C)) { + throw new $TypeError('O.constructor is not an Object'); + } + var S = $species ? C[$species] : void 0; + if (S == null) { + return defaultConstructor; + } + if (IsConstructor(S)) { + return S; + } + throw new $TypeError('no constructor found'); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/SplitMatch.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/SplitMatch.js new file mode 100644 index 0000000000000000000000000000000000000000..c04fa7f63c6884e6d40b21689784dae891ceb655 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/SplitMatch.js @@ -0,0 +1,35 @@ +'use strict'; + +var callBound = require('call-bound'); + +var $TypeError = require('es-errors/type'); +var isInteger = require('math-intrinsics/isInteger'); + +var $charAt = callBound('String.prototype.charAt'); + +// https://262.ecma-international.org/6.0/#sec-splitmatch + +module.exports = function SplitMatch(S, q, R) { + if (typeof S !== 'string') { + throw new $TypeError('Assertion failed: `S` must be a String'); + } + if (!isInteger(q)) { + throw new $TypeError('Assertion failed: `q` must be an integer'); + } + if (typeof R !== 'string') { + throw new $TypeError('Assertion failed: `R` must be a String'); + } + var r = R.length; + var s = S.length; + if (q + r > s) { + return false; + } + + for (var i = 0; i < r; i += 1) { + if ($charAt(S, q + i) !== $charAt(R, i)) { + return false; + } + } + + return q + r; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/StrictEqualityComparison.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/StrictEqualityComparison.js new file mode 100644 index 0000000000000000000000000000000000000000..d056c44e79a546022718908720ab19cd27e7415e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/StrictEqualityComparison.js @@ -0,0 +1,15 @@ +'use strict'; + +var Type = require('./Type'); + +// https://262.ecma-international.org/5.1/#sec-11.9.6 + +module.exports = function StrictEqualityComparison(x, y) { + if (Type(x) !== Type(y)) { + return false; + } + if (typeof x === 'undefined' || x === null) { + return true; + } + return x === y; // shortcut for steps 4-7 +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/StringCreate.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/StringCreate.js new file mode 100644 index 0000000000000000000000000000000000000000..3e2aa43c50d8aa6317c0eef7eaf0b87e32916d4d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/StringCreate.js @@ -0,0 +1,38 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $Object = require('es-object-atoms'); +var $StringPrototype = GetIntrinsic('%String.prototype%'); +var $SyntaxError = require('es-errors/syntax'); +var $TypeError = require('es-errors/type'); +var setProto = require('set-proto'); + +var DefinePropertyOrThrow = require('./DefinePropertyOrThrow'); + +// https://262.ecma-international.org/6.0/#sec-stringcreate + +module.exports = function StringCreate(value, prototype) { + if (typeof value !== 'string') { + throw new $TypeError('Assertion failed: `S` must be a String'); + } + + var S = $Object(value); + if (prototype !== $StringPrototype) { + if (setProto) { + setProto(S, prototype); + } else { + throw new $SyntaxError('StringCreate: a `proto` argument that is not `String.prototype` is not supported in an environment that does not support setting the [[Prototype]]'); + } + } + + var length = value.length; + DefinePropertyOrThrow(S, 'length', { + '[[Configurable]]': false, + '[[Enumerable]]': false, + '[[Value]]': length, + '[[Writable]]': false + }); + + return S; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/StringGetIndexProperty.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/StringGetIndexProperty.js new file mode 100644 index 0000000000000000000000000000000000000000..f40cd23eb3b11a2b4aea50590d3c08e10a658e87 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/StringGetIndexProperty.js @@ -0,0 +1,50 @@ +'use strict'; + +var callBound = require('call-bound'); + +var $TypeError = require('es-errors/type'); + +var $charAt = callBound('String.prototype.charAt'); + +var isString = require('is-string'); +var isNegativeZero = require('math-intrinsics/isNegativeZero'); +var unbox = require('unbox-primitive'); + +var CanonicalNumericIndexString = require('./CanonicalNumericIndexString'); +var IsInteger = require('./IsInteger'); +var isPropertyKey = require('../helpers/isPropertyKey'); + +// https://262.ecma-international.org/6.0/#sec-stringgetindexproperty + +module.exports = function StringGetIndexProperty(S, P) { + if (typeof S === 'string' || !isString(S)) { + throw new $TypeError('Assertion failed: `S` must be a boxed String Object'); + } + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: `P` must be a Property Key'); + } + + if (typeof P !== 'string') { + return void undefined; + } + + var index = CanonicalNumericIndexString(P); + if (typeof index === 'undefined' || !IsInteger(index) || isNegativeZero(index)) { + return void undefined; + } + + var str = unbox(S); + var len = str.length; + if (index < 0 || len <= index) { + return void undefined; + } + + var resultStr = $charAt(str, index); + + return { + '[[Configurable]]': false, + '[[Enumerable]]': true, + '[[Value]]': resultStr, + '[[Writable]]': false + }; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/SymbolDescriptiveString.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/SymbolDescriptiveString.js new file mode 100644 index 0000000000000000000000000000000000000000..444e3f70004626a3053f672a290e5e81b0f5cf51 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/SymbolDescriptiveString.js @@ -0,0 +1,16 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var callBound = require('call-bound'); + +var $SymbolToString = callBound('Symbol.prototype.toString', true); + +// https://262.ecma-international.org/6.0/#sec-symboldescriptivestring + +module.exports = function SymbolDescriptiveString(sym) { + if (typeof sym !== 'symbol') { + throw new $TypeError('Assertion failed: `sym` must be a Symbol'); + } + return $SymbolToString(sym); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/TestIntegrityLevel.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/TestIntegrityLevel.js new file mode 100644 index 0000000000000000000000000000000000000000..0e802f42786f89bac378b6a58e6009c9620be721 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/TestIntegrityLevel.js @@ -0,0 +1,40 @@ +'use strict'; + +var $gOPD = require('gopd'); +var $TypeError = require('es-errors/type'); + +var every = require('../helpers/every'); +var OwnPropertyKeys = require('own-keys'); +var isObject = require('es-object-atoms/isObject'); + +var IsDataDescriptor = require('./IsDataDescriptor'); +var IsExtensible = require('./IsExtensible'); +var ToPropertyDescriptor = require('./ToPropertyDescriptor'); + +// https://262.ecma-international.org/6.0/#sec-testintegritylevel + +module.exports = function TestIntegrityLevel(O, level) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: Type(O) is not Object'); + } + if (level !== 'sealed' && level !== 'frozen') { + throw new $TypeError('Assertion failed: `level` must be `"sealed"` or `"frozen"`'); + } + var status = IsExtensible(O); + if (status || !$gOPD) { + return false; + } + var theKeys = OwnPropertyKeys(O); + return theKeys.length === 0 || every(theKeys, function (k) { + var currentDesc = $gOPD(O, k); + if (typeof currentDesc !== 'undefined') { + if (currentDesc.configurable) { + return false; + } + if (level === 'frozen' && IsDataDescriptor(ToPropertyDescriptor(currentDesc)) && currentDesc.writable) { + return false; + } + } + return true; + }); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/TimeClip.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/TimeClip.js new file mode 100644 index 0000000000000000000000000000000000000000..77c8dd4226c4765855024b1784b842f869fa5bfe --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/TimeClip.js @@ -0,0 +1,20 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $Date = GetIntrinsic('%Date%'); + +var $isFinite = require('math-intrinsics/isFinite'); +var abs = require('math-intrinsics/abs'); + +var ToNumber = require('./ToNumber'); + +// https://262.ecma-international.org/5.1/#sec-15.9.1.14 + +module.exports = function TimeClip(time) { + if (!$isFinite(time) || abs(time) > 8.64e15) { + return NaN; + } + return +new $Date(ToNumber(time)); +}; + diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/TimeFromYear.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/TimeFromYear.js new file mode 100644 index 0000000000000000000000000000000000000000..f3518a41a19146c9ba59e1362c3fb33f800daaa1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/TimeFromYear.js @@ -0,0 +1,11 @@ +'use strict'; + +var msPerDay = require('../helpers/timeConstants').msPerDay; + +var DayFromYear = require('./DayFromYear'); + +// https://262.ecma-international.org/5.1/#sec-15.9.1.3 + +module.exports = function TimeFromYear(y) { + return msPerDay * DayFromYear(y); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/TimeWithinDay.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/TimeWithinDay.js new file mode 100644 index 0000000000000000000000000000000000000000..2bba83386c141873d3b603ed19d0f37069d1016a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/TimeWithinDay.js @@ -0,0 +1,12 @@ +'use strict'; + +var modulo = require('./modulo'); + +var msPerDay = require('../helpers/timeConstants').msPerDay; + +// https://262.ecma-international.org/5.1/#sec-15.9.1.2 + +module.exports = function TimeWithinDay(t) { + return modulo(t, msPerDay); +}; + diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToBoolean.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToBoolean.js new file mode 100644 index 0000000000000000000000000000000000000000..466404bf9992f0ba636249264c620d6c56215d6a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToBoolean.js @@ -0,0 +1,5 @@ +'use strict'; + +// http://262.ecma-international.org/5.1/#sec-9.2 + +module.exports = function ToBoolean(value) { return !!value; }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToDateString.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToDateString.js new file mode 100644 index 0000000000000000000000000000000000000000..d9bb434185ca0adfa055d91bf592efdce3ed1d94 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToDateString.js @@ -0,0 +1,21 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $TypeError = require('es-errors/type'); +var $Date = GetIntrinsic('%Date%'); +var $String = GetIntrinsic('%String%'); + +var $isNaN = require('math-intrinsics/isNaN'); + +// https://262.ecma-international.org/6.0/#sec-todatestring + +module.exports = function ToDateString(tv) { + if (typeof tv !== 'number') { + throw new $TypeError('Assertion failed: `tv` must be a Number'); + } + if ($isNaN(tv)) { + return 'Invalid Date'; + } + return $String(new $Date(tv)); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToInt16.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToInt16.js new file mode 100644 index 0000000000000000000000000000000000000000..21694bdeb923cd78791c7c01e242d892b4833af0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToInt16.js @@ -0,0 +1,10 @@ +'use strict'; + +var ToUint16 = require('./ToUint16'); + +// https://262.ecma-international.org/6.0/#sec-toint16 + +module.exports = function ToInt16(argument) { + var int16bit = ToUint16(argument); + return int16bit >= 0x8000 ? int16bit - 0x10000 : int16bit; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToInt32.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToInt32.js new file mode 100644 index 0000000000000000000000000000000000000000..b879ccc479e039097fa2d1017299579a2d8a8162 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToInt32.js @@ -0,0 +1,9 @@ +'use strict'; + +var ToNumber = require('./ToNumber'); + +// http://262.ecma-international.org/5.1/#sec-9.5 + +module.exports = function ToInt32(x) { + return ToNumber(x) >> 0; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToInt8.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToInt8.js new file mode 100644 index 0000000000000000000000000000000000000000..e223b6c1d352a3432da2d272d0f7e66bbfa818b4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToInt8.js @@ -0,0 +1,10 @@ +'use strict'; + +var ToUint8 = require('./ToUint8'); + +// https://262.ecma-international.org/6.0/#sec-toint8 + +module.exports = function ToInt8(argument) { + var int8bit = ToUint8(argument); + return int8bit >= 0x80 ? int8bit - 0x100 : int8bit; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToInteger.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToInteger.js new file mode 100644 index 0000000000000000000000000000000000000000..f6625796ebd22a688826a1bd5d36e20dfe6ebcc7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToInteger.js @@ -0,0 +1,12 @@ +'use strict'; + +var ES5ToInteger = require('../5/ToInteger'); + +var ToNumber = require('./ToNumber'); + +// https://262.ecma-international.org/6.0/#sec-tointeger + +module.exports = function ToInteger(value) { + var number = ToNumber(value); + return ES5ToInteger(number); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToLength.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToLength.js new file mode 100644 index 0000000000000000000000000000000000000000..afa8fb5576c98149d8b6e3327fde8370cd34794c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToLength.js @@ -0,0 +1,14 @@ +'use strict'; + +var MAX_SAFE_INTEGER = require('math-intrinsics/constants/maxSafeInteger'); + +var ToInteger = require('./ToInteger'); + +// https://262.ecma-international.org/6.0/#sec-tolength + +module.exports = function ToLength(argument) { + var len = ToInteger(argument); + if (len <= 0) { return 0; } // includes converting -0 to +0 + if (len > MAX_SAFE_INTEGER) { return MAX_SAFE_INTEGER; } + return len; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToNumber.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToNumber.js new file mode 100644 index 0000000000000000000000000000000000000000..c3d95a5fa51d6d66ec39b339e9d7839266c192ff --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToNumber.js @@ -0,0 +1,48 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $TypeError = require('es-errors/type'); +var $Number = GetIntrinsic('%Number%'); +var $RegExp = GetIntrinsic('%RegExp%'); +var $parseInteger = GetIntrinsic('%parseInt%'); + +var callBound = require('call-bound'); +var regexTester = require('safe-regex-test'); +var isPrimitive = require('../helpers/isPrimitive'); + +var $strSlice = callBound('String.prototype.slice'); +var isBinary = regexTester(/^0b[01]+$/i); +var isOctal = regexTester(/^0o[0-7]+$/i); +var isInvalidHexLiteral = regexTester(/^[-+]0x[0-9a-f]+$/i); +var nonWS = ['\u0085', '\u200b', '\ufffe'].join(''); +var nonWSregex = new $RegExp('[' + nonWS + ']', 'g'); +var hasNonWS = regexTester(nonWSregex); + +var $trim = require('string.prototype.trim'); + +var ToPrimitive = require('./ToPrimitive'); + +// https://262.ecma-international.org/6.0/#sec-tonumber + +module.exports = function ToNumber(argument) { + var value = isPrimitive(argument) ? argument : ToPrimitive(argument, $Number); + if (typeof value === 'symbol') { + throw new $TypeError('Cannot convert a Symbol value to a number'); + } + if (typeof value === 'string') { + if (isBinary(value)) { + return ToNumber($parseInteger($strSlice(value, 2), 2)); + } else if (isOctal(value)) { + return ToNumber($parseInteger($strSlice(value, 2), 8)); + } else if (hasNonWS(value) || isInvalidHexLiteral(value)) { + return NaN; + } + var trimmed = $trim(value); + if (trimmed !== value) { + return ToNumber(trimmed); + } + + } + return +value; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToObject.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToObject.js new file mode 100644 index 0000000000000000000000000000000000000000..70226aaa331e7fd7aa487e680d4aca6bb6874f5b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToObject.js @@ -0,0 +1,5 @@ +'use strict'; + +// https://262.ecma-international.org/6.0/#sec-toobject + +module.exports = require('es-object-atoms/ToObject'); diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToPrimitive.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToPrimitive.js new file mode 100644 index 0000000000000000000000000000000000000000..56bcf1aa9eb269d753119497686556384800b092 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToPrimitive.js @@ -0,0 +1,12 @@ +'use strict'; + +var toPrimitive = require('es-to-primitive/es2015'); + +// https://262.ecma-international.org/6.0/#sec-toprimitive + +module.exports = function ToPrimitive(input) { + if (arguments.length > 1) { + return toPrimitive(input, arguments[1]); + } + return toPrimitive(input); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToPropertyDescriptor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToPropertyDescriptor.js new file mode 100644 index 0000000000000000000000000000000000000000..017350d593b202573a928ccefeacc7472c803a5e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToPropertyDescriptor.js @@ -0,0 +1,50 @@ +'use strict'; + +var hasOwn = require('hasown'); + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var IsCallable = require('./IsCallable'); +var ToBoolean = require('./ToBoolean'); + +// https://262.ecma-international.org/5.1/#sec-8.10.5 + +module.exports = function ToPropertyDescriptor(Obj) { + if (!isObject(Obj)) { + throw new $TypeError('ToPropertyDescriptor requires an object'); + } + + var desc = {}; + if (hasOwn(Obj, 'enumerable')) { + desc['[[Enumerable]]'] = ToBoolean(Obj.enumerable); + } + if (hasOwn(Obj, 'configurable')) { + desc['[[Configurable]]'] = ToBoolean(Obj.configurable); + } + if (hasOwn(Obj, 'value')) { + desc['[[Value]]'] = Obj.value; + } + if (hasOwn(Obj, 'writable')) { + desc['[[Writable]]'] = ToBoolean(Obj.writable); + } + if (hasOwn(Obj, 'get')) { + var getter = Obj.get; + if (typeof getter !== 'undefined' && !IsCallable(getter)) { + throw new $TypeError('getter must be a function'); + } + desc['[[Get]]'] = getter; + } + if (hasOwn(Obj, 'set')) { + var setter = Obj.set; + if (typeof setter !== 'undefined' && !IsCallable(setter)) { + throw new $TypeError('setter must be a function'); + } + desc['[[Set]]'] = setter; + } + + if ((hasOwn(desc, '[[Get]]') || hasOwn(desc, '[[Set]]')) && (hasOwn(desc, '[[Value]]') || hasOwn(desc, '[[Writable]]'))) { + throw new $TypeError('Invalid property descriptor. Cannot both specify accessors and a value or writable attribute'); + } + return desc; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToPropertyKey.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToPropertyKey.js new file mode 100644 index 0000000000000000000000000000000000000000..e363cd93b1722ddcff99896fb5667079bb95c932 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToPropertyKey.js @@ -0,0 +1,15 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $String = GetIntrinsic('%String%'); + +var ToPrimitive = require('./ToPrimitive'); +var ToString = require('./ToString'); + +// https://262.ecma-international.org/6.0/#sec-topropertykey + +module.exports = function ToPropertyKey(argument) { + var key = ToPrimitive(argument, $String); + return typeof key === 'symbol' ? key : ToString(key); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToString.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToString.js new file mode 100644 index 0000000000000000000000000000000000000000..16b4ccf893640ee9162ff07ad484038311e6210d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToString.js @@ -0,0 +1,15 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $String = GetIntrinsic('%String%'); +var $TypeError = require('es-errors/type'); + +// https://262.ecma-international.org/6.0/#sec-tostring + +module.exports = function ToString(argument) { + if (typeof argument === 'symbol') { + throw new $TypeError('Cannot convert a Symbol value to a string'); + } + return $String(argument); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToUint16.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToUint16.js new file mode 100644 index 0000000000000000000000000000000000000000..117485e616437b348b9b74dddc3fc5e7af9f9ed0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToUint16.js @@ -0,0 +1,19 @@ +'use strict'; + +var modulo = require('./modulo'); +var ToNumber = require('./ToNumber'); + +var abs = require('math-intrinsics/abs'); +var floor = require('math-intrinsics/floor'); +var $isNaN = require('math-intrinsics/isNaN'); +var $isFinite = require('math-intrinsics/isFinite'); +var $sign = require('math-intrinsics/sign'); + +// http://262.ecma-international.org/5.1/#sec-9.7 + +module.exports = function ToUint16(value) { + var number = ToNumber(value); + if ($isNaN(number) || number === 0 || !$isFinite(number)) { return 0; } + var posInt = $sign(number) * floor(abs(number)); + return modulo(posInt, 0x10000); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToUint32.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToUint32.js new file mode 100644 index 0000000000000000000000000000000000000000..2a8e9dd6a3794a0940b6bae175a99f00c0e2d25d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToUint32.js @@ -0,0 +1,9 @@ +'use strict'; + +var ToNumber = require('./ToNumber'); + +// http://262.ecma-international.org/5.1/#sec-9.6 + +module.exports = function ToUint32(x) { + return ToNumber(x) >>> 0; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToUint8.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToUint8.js new file mode 100644 index 0000000000000000000000000000000000000000..e3af8ede13a7ef1e5e3eb8833701d6497f8611e0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToUint8.js @@ -0,0 +1,19 @@ +'use strict'; + +var ToNumber = require('./ToNumber'); + +var $isNaN = require('math-intrinsics/isNaN'); +var $isFinite = require('math-intrinsics/isFinite'); +var $sign = require('math-intrinsics/sign'); +var abs = require('math-intrinsics/abs'); +var floor = require('math-intrinsics/floor'); +var modulo = require('math-intrinsics/mod'); + +// https://262.ecma-international.org/6.0/#sec-touint8 + +module.exports = function ToUint8(argument) { + var number = ToNumber(argument); + if ($isNaN(number) || number === 0 || !$isFinite(number)) { return 0; } + var posInt = $sign(number) * floor(abs(number)); + return modulo(posInt, 0x100); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToUint8Clamp.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToUint8Clamp.js new file mode 100644 index 0000000000000000000000000000000000000000..ac1b06e461ba4d562700971000c2d30a9b9dfca4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ToUint8Clamp.js @@ -0,0 +1,19 @@ +'use strict'; + +var ToNumber = require('./ToNumber'); +var floor = require('./floor'); + +var $isNaN = require('math-intrinsics/isNaN'); + +// https://262.ecma-international.org/6.0/#sec-touint8clamp + +module.exports = function ToUint8Clamp(argument) { + var number = ToNumber(argument); + if ($isNaN(number) || number <= 0) { return 0; } + if (number >= 0xFF) { return 0xFF; } + var f = floor(number); + if (f + 0.5 < number) { return f + 1; } + if (number < f + 0.5) { return f; } + if (f % 2 !== 0) { return f + 1; } + return f; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/Type.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/Type.js new file mode 100644 index 0000000000000000000000000000000000000000..da5cb762508f187a91583bfc2d509036d492aa66 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/Type.js @@ -0,0 +1,12 @@ +'use strict'; + +var ES5Type = require('../5/Type'); + +// https://262.ecma-international.org/6.0/#sec-ecmascript-data-types-and-values + +module.exports = function Type(x) { + if (typeof x === 'symbol') { + return 'Symbol'; + } + return ES5Type(x); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ValidateAndApplyPropertyDescriptor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ValidateAndApplyPropertyDescriptor.js new file mode 100644 index 0000000000000000000000000000000000000000..12cab5dff05ac5d79240ac4b40af54aa99c5fd5e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ValidateAndApplyPropertyDescriptor.js @@ -0,0 +1,159 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var DefineOwnProperty = require('../helpers/DefineOwnProperty'); +var isPropertyDescriptor = require('../helpers/records/property-descriptor'); +var isSamePropertyDescriptor = require('../helpers/isSamePropertyDescriptor'); + +var FromPropertyDescriptor = require('./FromPropertyDescriptor'); +var IsAccessorDescriptor = require('./IsAccessorDescriptor'); +var IsDataDescriptor = require('./IsDataDescriptor'); +var IsGenericDescriptor = require('./IsGenericDescriptor'); +var isPropertyKey = require('../helpers/isPropertyKey'); +var SameValue = require('./SameValue'); + +// https://262.ecma-international.org/6.0/#sec-validateandapplypropertydescriptor +// https://262.ecma-international.org/8.0/#sec-validateandapplypropertydescriptor + +// eslint-disable-next-line max-lines-per-function, max-statements +module.exports = function ValidateAndApplyPropertyDescriptor(O, P, extensible, Desc, current) { + // this uses the ES2017+ logic, since it fixes a number of bugs in the ES2015 logic. + if (typeof O !== 'undefined' && !isObject(O)) { + throw new $TypeError('Assertion failed: O must be undefined or an Object'); + } + if (typeof extensible !== 'boolean') { + throw new $TypeError('Assertion failed: extensible must be a Boolean'); + } + if (!isPropertyDescriptor(Desc)) { + throw new $TypeError('Assertion failed: Desc must be a Property Descriptor'); + } + if (typeof current !== 'undefined' && !isPropertyDescriptor(current)) { + throw new $TypeError('Assertion failed: current must be a Property Descriptor, or undefined'); + } + if (typeof O !== 'undefined' && !isPropertyKey(P)) { + throw new $TypeError('Assertion failed: if O is not undefined, P must be a Property Key'); + } + if (typeof current === 'undefined') { + if (!extensible) { + return false; + } + if (IsGenericDescriptor(Desc) || IsDataDescriptor(Desc)) { + if (typeof O !== 'undefined') { + DefineOwnProperty( + IsDataDescriptor, + SameValue, + FromPropertyDescriptor, + O, + P, + { + '[[Configurable]]': Desc['[[Configurable]]'], + '[[Enumerable]]': Desc['[[Enumerable]]'], + '[[Value]]': Desc['[[Value]]'], + '[[Writable]]': Desc['[[Writable]]'] + } + ); + } + } else { + if (!IsAccessorDescriptor(Desc)) { + throw new $TypeError('Assertion failed: Desc is not an accessor descriptor'); + } + if (typeof O !== 'undefined') { + return DefineOwnProperty( + IsDataDescriptor, + SameValue, + FromPropertyDescriptor, + O, + P, + Desc + ); + } + } + return true; + } + if (IsGenericDescriptor(Desc) && !('[[Configurable]]' in Desc) && !('[[Enumerable]]' in Desc)) { + return true; + } + if (isSamePropertyDescriptor({ SameValue: SameValue }, Desc, current)) { + return true; // removed by ES2017, but should still be correct + } + // "if every field in Desc is absent, return true" can't really match the assertion that it's a Property Descriptor + if (!current['[[Configurable]]']) { + if (Desc['[[Configurable]]']) { + return false; + } + if ('[[Enumerable]]' in Desc && !Desc['[[Enumerable]]'] === !!current['[[Enumerable]]']) { + return false; + } + } + if (IsGenericDescriptor(Desc)) { + // no further validation is required. + } else if (IsDataDescriptor(current) !== IsDataDescriptor(Desc)) { + if (!current['[[Configurable]]']) { + return false; + } + if (IsDataDescriptor(current)) { + if (typeof O !== 'undefined') { + DefineOwnProperty( + IsDataDescriptor, + SameValue, + FromPropertyDescriptor, + O, + P, + { + '[[Configurable]]': current['[[Configurable]]'], + '[[Enumerable]]': current['[[Enumerable]]'], + '[[Get]]': undefined + } + ); + } + } else if (typeof O !== 'undefined') { + DefineOwnProperty( + IsDataDescriptor, + SameValue, + FromPropertyDescriptor, + O, + P, + { + '[[Configurable]]': current['[[Configurable]]'], + '[[Enumerable]]': current['[[Enumerable]]'], + '[[Value]]': undefined + } + ); + } + } else if (IsDataDescriptor(current) && IsDataDescriptor(Desc)) { + if (!current['[[Configurable]]'] && !current['[[Writable]]']) { + if ('[[Writable]]' in Desc && Desc['[[Writable]]']) { + return false; + } + if ('[[Value]]' in Desc && !SameValue(Desc['[[Value]]'], current['[[Value]]'])) { + return false; + } + return true; + } + } else if (IsAccessorDescriptor(current) && IsAccessorDescriptor(Desc)) { + if (!current['[[Configurable]]']) { + if ('[[Set]]' in Desc && !SameValue(Desc['[[Set]]'], current['[[Set]]'])) { + return false; + } + if ('[[Get]]' in Desc && !SameValue(Desc['[[Get]]'], current['[[Get]]'])) { + return false; + } + return true; + } + } else { + throw new $TypeError('Assertion failed: current and Desc are not both data, both accessors, or one accessor and one data.'); + } + if (typeof O !== 'undefined') { + return DefineOwnProperty( + IsDataDescriptor, + SameValue, + FromPropertyDescriptor, + O, + P, + Desc + ); + } + return true; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ValidateTypedArray.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ValidateTypedArray.js new file mode 100644 index 0000000000000000000000000000000000000000..87fa8d17872f4463582e77a803dc98ff0019f878 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/ValidateTypedArray.js @@ -0,0 +1,28 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var IsDetachedBuffer = require('./IsDetachedBuffer'); + +var isTypedArray = require('is-typed-array'); +var typedArrayBuffer = require('typed-array-buffer'); + +// https://262.ecma-international.org/6.0/#sec-validatetypedarray + +module.exports = function ValidateTypedArray(O) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: `O` must be an Object'); // step 1 + } + if (!isTypedArray(O)) { + throw new $TypeError('Assertion failed: `O` must be a Typed Array'); // steps 2 - 3 + } + + var buffer = typedArrayBuffer(O); // step 4 + + if (IsDetachedBuffer(buffer)) { + throw new $TypeError('`O` must be backed by a non-detached buffer'); // step 5 + } + + return buffer; // step 6 +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/WeekDay.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/WeekDay.js new file mode 100644 index 0000000000000000000000000000000000000000..17cf94ca34ce0aae649c1e0236cd18f248d54e3d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/WeekDay.js @@ -0,0 +1,10 @@ +'use strict'; + +var Day = require('./Day'); +var modulo = require('./modulo'); + +// https://262.ecma-international.org/5.1/#sec-15.9.1.6 + +module.exports = function WeekDay(t) { + return modulo(Day(t) + 4, 7); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/YearFromTime.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/YearFromTime.js new file mode 100644 index 0000000000000000000000000000000000000000..18958182021b0ecc71645057fe8ed826ef786586 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/YearFromTime.js @@ -0,0 +1,16 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $Date = GetIntrinsic('%Date%'); + +var callBound = require('call-bound'); + +var $getUTCFullYear = callBound('Date.prototype.getUTCFullYear'); + +// https://262.ecma-international.org/5.1/#sec-15.9.1.3 + +module.exports = function YearFromTime(t) { + // largest y such that this.TimeFromYear(y) <= t + return $getUTCFullYear(new $Date(t)); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/abs.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/abs.js new file mode 100644 index 0000000000000000000000000000000000000000..342aa85c66060f7b1cf3a8773cea18b487f3f0a4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/abs.js @@ -0,0 +1,9 @@ +'use strict'; + +var $abs = require('math-intrinsics/abs'); + +// https://262.ecma-international.org/5.1/#sec-5.2 + +module.exports = function abs(x) { + return $abs(x); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/floor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/floor.js new file mode 100644 index 0000000000000000000000000000000000000000..cc53b951167e8f73498de0a1f0e970c52c598f80 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/floor.js @@ -0,0 +1,11 @@ +'use strict'; + +// var modulo = require('./modulo'); +var $floor = require('math-intrinsics/floor'); + +// http://262.ecma-international.org/5.1/#sec-5.2 + +module.exports = function floor(x) { + // return x - modulo(x, 1); + return $floor(x); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/max.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/max.js new file mode 100644 index 0000000000000000000000000000000000000000..f83b038a221fed3a500c72b41f5fdc31e1100827 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/max.js @@ -0,0 +1,5 @@ +'use strict'; + +// https://262.ecma-international.org/6.0/#sec-algorithm-conventions + +module.exports = require('math-intrinsics/max'); diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/min.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/min.js new file mode 100644 index 0000000000000000000000000000000000000000..3a8f50539f0a6519251299edf4169f98a6db0bd9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/min.js @@ -0,0 +1,5 @@ +'use strict'; + +// https://262.ecma-international.org/6.0/#sec-algorithm-conventions + +module.exports = require('math-intrinsics/min'); diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/modulo.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/modulo.js new file mode 100644 index 0000000000000000000000000000000000000000..b94bb52bb3c62e45629a4b1e8f0ebba219d5e41e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/modulo.js @@ -0,0 +1,9 @@ +'use strict'; + +var mod = require('../helpers/mod'); + +// https://262.ecma-international.org/5.1/#sec-5.2 + +module.exports = function modulo(x, y) { + return mod(x, y); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/msFromTime.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/msFromTime.js new file mode 100644 index 0000000000000000000000000000000000000000..a6bae767aed31c8a467b8ea1fb2128e64860a972 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/msFromTime.js @@ -0,0 +1,11 @@ +'use strict'; + +var modulo = require('./modulo'); + +var msPerSecond = require('../helpers/timeConstants').msPerSecond; + +// https://262.ecma-international.org/5.1/#sec-15.9.1.10 + +module.exports = function msFromTime(t) { + return modulo(t, msPerSecond); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/thisBooleanValue.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/thisBooleanValue.js new file mode 100644 index 0000000000000000000000000000000000000000..265fff335bed60f2a636b2fa3bf2ac113b896ff7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/thisBooleanValue.js @@ -0,0 +1,13 @@ +'use strict'; + +var $BooleanValueOf = require('call-bound')('Boolean.prototype.valueOf'); + +// https://262.ecma-international.org/6.0/#sec-properties-of-the-boolean-prototype-object + +module.exports = function thisBooleanValue(value) { + if (typeof value === 'boolean') { + return value; + } + + return $BooleanValueOf(value); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/thisNumberValue.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/thisNumberValue.js new file mode 100644 index 0000000000000000000000000000000000000000..e2457fb3f076d4f8c500d7f5ce7b19ff4846cf2d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/thisNumberValue.js @@ -0,0 +1,16 @@ +'use strict'; + +var callBound = require('call-bound'); + +var $NumberValueOf = callBound('Number.prototype.valueOf'); + +// https://262.ecma-international.org/6.0/#sec-properties-of-the-number-prototype-object + +module.exports = function thisNumberValue(value) { + if (typeof value === 'number') { + return value; + } + + return $NumberValueOf(value); +}; + diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/thisStringValue.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/thisStringValue.js new file mode 100644 index 0000000000000000000000000000000000000000..a5c70534670cd719ca425055d597ac6b5f5994c2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/thisStringValue.js @@ -0,0 +1,13 @@ +'use strict'; + +var $StringValueOf = require('call-bound')('String.prototype.valueOf'); + +// https://262.ecma-international.org/6.0/#sec-properties-of-the-string-prototype-object + +module.exports = function thisStringValue(value) { + if (typeof value === 'string') { + return value; + } + + return $StringValueOf(value); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/thisTimeValue.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/thisTimeValue.js new file mode 100644 index 0000000000000000000000000000000000000000..f64be83fcaed6a3766a1397c1c373981c0543b1a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2015/thisTimeValue.js @@ -0,0 +1,9 @@ +'use strict'; + +var timeValue = require('../helpers/timeValue'); + +// https://262.ecma-international.org/6.0/#sec-properties-of-the-date-prototype-object + +module.exports = function thisTimeValue(value) { + return timeValue(value); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/AbstractEqualityComparison.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/AbstractEqualityComparison.js new file mode 100644 index 0000000000000000000000000000000000000000..04522eabb827592704c5e463cb3528566fca845f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/AbstractEqualityComparison.js @@ -0,0 +1,38 @@ +'use strict'; + +var ToNumber = require('./ToNumber'); +var ToPrimitive = require('./ToPrimitive'); + +var isSameType = require('../helpers/isSameType'); + +var isObject = require('es-object-atoms/isObject'); + +// https://262.ecma-international.org/6.0/#sec-abstract-equality-comparison + +module.exports = function AbstractEqualityComparison(x, y) { + if (isSameType(x, y)) { + return x === y; // ES6+ specified this shortcut anyways. + } + if (x == null && y == null) { + return true; + } + if (typeof x === 'number' && typeof y === 'string') { + return AbstractEqualityComparison(x, ToNumber(y)); + } + if (typeof x === 'string' && typeof y === 'number') { + return AbstractEqualityComparison(ToNumber(x), y); + } + if (typeof x === 'boolean') { + return AbstractEqualityComparison(ToNumber(x), y); + } + if (typeof y === 'boolean') { + return AbstractEqualityComparison(x, ToNumber(y)); + } + if ((typeof x === 'string' || typeof x === 'number' || typeof x === 'symbol') && isObject(y)) { + return AbstractEqualityComparison(x, ToPrimitive(y)); + } + if (isObject(x) && (typeof y === 'string' || typeof y === 'number' || typeof y === 'symbol')) { + return AbstractEqualityComparison(ToPrimitive(x), y); + } + return false; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/AbstractRelationalComparison.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/AbstractRelationalComparison.js new file mode 100644 index 0000000000000000000000000000000000000000..443cfe0c767c876171b94fd060556bd037666807 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/AbstractRelationalComparison.js @@ -0,0 +1,62 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $Number = GetIntrinsic('%Number%'); +var $TypeError = require('es-errors/type'); +var $isNaN = require('math-intrinsics/isNaN'); +var $isFinite = require('math-intrinsics/isFinite'); + +var isPrefixOf = require('../helpers/isPrefixOf'); + +var ToNumber = require('./ToNumber'); +var ToPrimitive = require('./ToPrimitive'); + +// https://262.ecma-international.org/5.1/#sec-11.8.5 + +// eslint-disable-next-line max-statements +module.exports = function AbstractRelationalComparison(x, y, LeftFirst) { + if (typeof LeftFirst !== 'boolean') { + throw new $TypeError('Assertion failed: LeftFirst argument must be a Boolean'); + } + var px; + var py; + if (LeftFirst) { + px = ToPrimitive(x, $Number); + py = ToPrimitive(y, $Number); + } else { + py = ToPrimitive(y, $Number); + px = ToPrimitive(x, $Number); + } + var bothStrings = typeof px === 'string' && typeof py === 'string'; + if (!bothStrings) { + var nx = ToNumber(px); + var ny = ToNumber(py); + if ($isNaN(nx) || $isNaN(ny)) { + return undefined; + } + if ($isFinite(nx) && $isFinite(ny) && nx === ny) { + return false; + } + if (nx === Infinity) { + return false; + } + if (ny === Infinity) { + return true; + } + if (ny === -Infinity) { + return false; + } + if (nx === -Infinity) { + return true; + } + return nx < ny; // by now, these are both nonzero, finite, and not equal + } + if (isPrefixOf(py, px)) { + return false; + } + if (isPrefixOf(px, py)) { + return true; + } + return px < py; // both strings, neither a prefix of the other. shortcut for steps c-f +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/AdvanceStringIndex.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/AdvanceStringIndex.js new file mode 100644 index 0000000000000000000000000000000000000000..dac7a286dca6f3d387e9f7057eeb0739cc48be23 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/AdvanceStringIndex.js @@ -0,0 +1,44 @@ +'use strict'; + +var isInteger = require('math-intrinsics/isInteger'); +var MAX_SAFE_INTEGER = require('math-intrinsics/constants/maxSafeInteger'); + +var isLeadingSurrogate = require('../helpers/isLeadingSurrogate'); +var isTrailingSurrogate = require('../helpers/isTrailingSurrogate'); + +var $TypeError = require('es-errors/type'); + +var $charCodeAt = require('call-bound')('String.prototype.charCodeAt'); + +// https://262.ecma-international.org/6.0/#sec-advancestringindex + +module.exports = function AdvanceStringIndex(S, index, unicode) { + if (typeof S !== 'string') { + throw new $TypeError('Assertion failed: `S` must be a String'); + } + if (!isInteger(index) || index < 0 || index > MAX_SAFE_INTEGER) { + throw new $TypeError('Assertion failed: `length` must be an integer >= 0 and <= 2**53'); + } + if (typeof unicode !== 'boolean') { + throw new $TypeError('Assertion failed: `unicode` must be a Boolean'); + } + if (!unicode) { + return index + 1; + } + var length = S.length; + if ((index + 1) >= length) { + return index + 1; + } + + var first = $charCodeAt(S, index); + if (!isLeadingSurrogate(first)) { + return index + 1; + } + + var second = $charCodeAt(S, index + 1); + if (!isTrailingSurrogate(second)) { + return index + 1; + } + + return index + 2; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ArrayCreate.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ArrayCreate.js new file mode 100644 index 0000000000000000000000000000000000000000..8ed55aa2950b86640e487c905e4b73c543d71680 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ArrayCreate.js @@ -0,0 +1,42 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $ArrayPrototype = GetIntrinsic('%Array.prototype%'); +var $RangeError = require('es-errors/range'); +var $SyntaxError = require('es-errors/syntax'); +var $TypeError = require('es-errors/type'); +var isInteger = require('math-intrinsics/isInteger'); +var MAX_ARRAY_LENGTH = require('math-intrinsics/constants/maxArrayLength'); +var $setProto = require('set-proto'); + +// https://262.ecma-international.org/6.0/#sec-arraycreate + +module.exports = function ArrayCreate(length) { + if (!isInteger(length) || length < 0) { + throw new $TypeError('Assertion failed: `length` must be an integer Number >= 0'); + } + if (length > MAX_ARRAY_LENGTH) { + throw new $RangeError('length is greater than (2**32 - 1)'); + } + var proto = arguments.length > 1 ? arguments[1] : $ArrayPrototype; + var A = []; // steps 5 - 7, and 9 + if (proto !== $ArrayPrototype) { // step 8 + if (!$setProto) { + throw new $SyntaxError('ArrayCreate: a `proto` argument that is not `Array.prototype` is not supported in an environment that does not support setting the [[Prototype]]'); + } + $setProto(A, proto); + } + if (length !== 0) { // bypasses the need for step 2 + A.length = length; + } + /* step 10, the above as a shortcut for the below + OrdinaryDefineOwnProperty(A, 'length', { + '[[Configurable]]': false, + '[[Enumerable]]': false, + '[[Value]]': length, + '[[Writable]]': true + }); + */ + return A; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ArraySetLength.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ArraySetLength.js new file mode 100644 index 0000000000000000000000000000000000000000..7f7a4339c2af5c8656165189f47c4212732ee1bd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ArraySetLength.js @@ -0,0 +1,77 @@ +'use strict'; + +var $RangeError = require('es-errors/range'); +var $TypeError = require('es-errors/type'); + +var assign = require('object.assign'); + +var isPropertyDescriptor = require('../helpers/records/property-descriptor'); + +var IsArray = require('./IsArray'); +var IsDataDescriptor = require('./IsDataDescriptor'); +var OrdinaryDefineOwnProperty = require('./OrdinaryDefineOwnProperty'); +var OrdinaryGetOwnProperty = require('./OrdinaryGetOwnProperty'); +var ToNumber = require('./ToNumber'); +var ToString = require('./ToString'); +var ToUint32 = require('./ToUint32'); + +// https://262.ecma-international.org/6.0/#sec-arraysetlength + +// eslint-disable-next-line max-statements, max-lines-per-function +module.exports = function ArraySetLength(A, Desc) { + if (!IsArray(A)) { + throw new $TypeError('Assertion failed: A must be an Array'); + } + if (!isPropertyDescriptor(Desc)) { + throw new $TypeError('Assertion failed: Desc must be a Property Descriptor'); + } + if (!('[[Value]]' in Desc)) { + return OrdinaryDefineOwnProperty(A, 'length', Desc); + } + var newLenDesc = assign({}, Desc); + var newLen = ToUint32(Desc['[[Value]]']); + var numberLen = ToNumber(Desc['[[Value]]']); + if (newLen !== numberLen) { + throw new $RangeError('Invalid array length'); + } + newLenDesc['[[Value]]'] = newLen; + var oldLenDesc = OrdinaryGetOwnProperty(A, 'length'); + if (!IsDataDescriptor(oldLenDesc)) { + throw new $TypeError('Assertion failed: an array had a non-data descriptor on `length`'); + } + var oldLen = oldLenDesc['[[Value]]']; + if (newLen >= oldLen) { + return OrdinaryDefineOwnProperty(A, 'length', newLenDesc); + } + if (!oldLenDesc['[[Writable]]']) { + return false; + } + var newWritable; + if (!('[[Writable]]' in newLenDesc) || newLenDesc['[[Writable]]']) { + newWritable = true; + } else { + newWritable = false; + newLenDesc['[[Writable]]'] = true; + } + var succeeded = OrdinaryDefineOwnProperty(A, 'length', newLenDesc); + if (!succeeded) { + return false; + } + while (newLen < oldLen) { + oldLen -= 1; + // eslint-disable-next-line no-param-reassign + var deleteSucceeded = delete A[ToString(oldLen)]; + if (!deleteSucceeded) { + newLenDesc['[[Value]]'] = oldLen + 1; + if (!newWritable) { + newLenDesc['[[Writable]]'] = false; + OrdinaryDefineOwnProperty(A, 'length', newLenDesc); + return false; + } + } + } + if (!newWritable) { + return OrdinaryDefineOwnProperty(A, 'length', { '[[Writable]]': false }); + } + return true; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ArraySpeciesCreate.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ArraySpeciesCreate.js new file mode 100644 index 0000000000000000000000000000000000000000..8be185bd97d9c1d975ac93d279dd9d502790e51b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ArraySpeciesCreate.js @@ -0,0 +1,46 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $Array = GetIntrinsic('%Array%'); +var $species = GetIntrinsic('%Symbol.species%', true); +var $TypeError = require('es-errors/type'); +var isInteger = require('math-intrinsics/isInteger'); +var isObject = require('es-object-atoms/isObject'); + +var Get = require('./Get'); +var IsArray = require('./IsArray'); +var IsConstructor = require('./IsConstructor'); + +// https://262.ecma-international.org/6.0/#sec-arrayspeciescreate + +module.exports = function ArraySpeciesCreate(originalArray, length) { + if (!isInteger(length) || length < 0) { + throw new $TypeError('Assertion failed: length must be an integer >= 0'); + } + var len = length === 0 ? 0 : length; + var C; + var isArray = IsArray(originalArray); + if (isArray) { + C = Get(originalArray, 'constructor'); + // TODO: figure out how to make a cross-realm normal Array, a same-realm Array + // if (IsConstructor(C)) { + // if C is another realm's Array, C = undefined + // Object.getPrototypeOf(Object.getPrototypeOf(Object.getPrototypeOf(Array))) === null ? + // } + if ($species && isObject(C)) { + C = Get(C, $species); + if (C === null) { + C = void 0; + } + } + } + if (typeof C === 'undefined') { + return $Array(len); + } + if (!IsConstructor(C)) { + throw new $TypeError('C must be a constructor'); + } + return new C(len); // Construct(C, len); +}; + diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/Call.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/Call.js new file mode 100644 index 0000000000000000000000000000000000000000..90b3519cb954848f531c4921eaa79ec7d37d06bd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/Call.js @@ -0,0 +1,20 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); +var callBound = require('call-bound'); + +var $TypeError = require('es-errors/type'); + +var IsArray = require('./IsArray'); + +var $apply = GetIntrinsic('%Reflect.apply%', true) || callBound('Function.prototype.apply'); + +// https://262.ecma-international.org/6.0/#sec-call + +module.exports = function Call(F, V) { + var argumentsList = arguments.length > 2 ? arguments[2] : []; + if (!IsArray(argumentsList)) { + throw new $TypeError('Assertion failed: optional `argumentsList`, if provided, must be a List'); + } + return $apply(F, V, argumentsList); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CanonicalNumericIndexString.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CanonicalNumericIndexString.js new file mode 100644 index 0000000000000000000000000000000000000000..74ed02f050d21c13dbfc06c80c21ae20a8e530ee --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CanonicalNumericIndexString.js @@ -0,0 +1,19 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var SameValue = require('./SameValue'); +var ToNumber = require('./ToNumber'); +var ToString = require('./ToString'); + +// https://262.ecma-international.org/6.0/#sec-canonicalnumericindexstring + +module.exports = function CanonicalNumericIndexString(argument) { + if (typeof argument !== 'string') { + throw new $TypeError('Assertion failed: `argument` must be a String'); + } + if (argument === '-0') { return -0; } + var n = ToNumber(argument); + if (SameValue(ToString(n), argument)) { return n; } + return void 0; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/Canonicalize.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/Canonicalize.js new file mode 100644 index 0000000000000000000000000000000000000000..63a58c4028e12d41fc2775615441ea23228b6719 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/Canonicalize.js @@ -0,0 +1,51 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var callBound = require('call-bound'); +var hasOwn = require('hasown'); + +var $charCodeAt = callBound('String.prototype.charCodeAt'); +var $toUpperCase = callBound('String.prototype.toUpperCase'); + +var caseFolding = require('../helpers/caseFolding.json'); + +// https://262.ecma-international.org/6.0/#sec-runtime-semantics-canonicalize-ch + +module.exports = function Canonicalize(ch, IgnoreCase, Unicode) { + if (typeof ch !== 'string') { + throw new $TypeError('Assertion failed: `ch` must be a character'); + } + + if (typeof IgnoreCase !== 'boolean' || typeof Unicode !== 'boolean') { + throw new $TypeError('Assertion failed: `IgnoreCase` and `Unicode` must be Booleans'); + } + + if (!IgnoreCase) { + return ch; // step 1 + } + + if (Unicode) { // step 2 + if (hasOwn(caseFolding.C, ch)) { + return caseFolding.C[ch]; + } + if (hasOwn(caseFolding.S, ch)) { + return caseFolding.S[ch]; + } + return ch; // step 2.b + } + + var u = $toUpperCase(ch); // step 2 + + if (u.length !== 1) { + return ch; // step 3 + } + + var cu = u; // step 4 + + if ($charCodeAt(ch, 0) >= 128 && $charCodeAt(cu, 0) < 128) { + return ch; // step 5 + } + + return cu; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CharacterRange.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CharacterRange.js new file mode 100644 index 0000000000000000000000000000000000000000..e41cb7870a7411344a21dfe7fbfc7cd6888b7c9e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CharacterRange.js @@ -0,0 +1,53 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); +var callBound = require('call-bound'); + +var $fromCharCode = GetIntrinsic('%String.fromCharCode%'); +var $TypeError = require('es-errors/type'); +var $charCodeAt = callBound('String.prototype.charCodeAt'); + +var CharSet = require('../helpers/CharSet').CharSet; + +module.exports = function CharacterRange(A, B) { + var a; + var b; + + if (A instanceof CharSet || B instanceof CharSet) { + if (!(A instanceof CharSet) || !(B instanceof CharSet)) { + throw new $TypeError('Assertion failed: CharSets A and B are not both CharSets'); + } + + A.yield(function (c) { + if (typeof a !== 'undefined') { + throw new $TypeError('Assertion failed: CharSet A has more than one character'); + } + a = c; + }); + B.yield(function (c) { + if (typeof b !== 'undefined') { + throw new $TypeError('Assertion failed: CharSet B has more than one character'); + } + b = c; + }); + } else { + if (A.length !== 1 || B.length !== 1) { + throw new $TypeError('Assertion failed: CharSets A and B contain exactly one character'); + } + a = A[0]; + b = B[0]; + } + + var i = $charCodeAt(a, 0); + var j = $charCodeAt(b, 0); + + if (!(i <= j)) { + throw new $TypeError('Assertion failed: i is not <= j'); + } + + var arr = []; + for (var k = i; k <= j; k += 1) { + arr[arr.length] = $fromCharCode(k); + } + return arr; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CompletePropertyDescriptor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CompletePropertyDescriptor.js new file mode 100644 index 0000000000000000000000000000000000000000..8c9e3f441111638a3b3c9fd69857d3da22c779ee --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CompletePropertyDescriptor.js @@ -0,0 +1,43 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var hasOwn = require('hasown'); + +var IsDataDescriptor = require('./IsDataDescriptor'); +var IsGenericDescriptor = require('./IsGenericDescriptor'); + +var isPropertyDescriptor = require('../helpers/records/property-descriptor'); + +// https://262.ecma-international.org/6.0/#sec-completepropertydescriptor + +module.exports = function CompletePropertyDescriptor(Desc) { + if (!isPropertyDescriptor(Desc)) { + throw new $TypeError('Assertion failed: `Desc` must be a Property Descriptor'); + } + + /* eslint no-param-reassign: 0 */ + + if (IsGenericDescriptor(Desc) || IsDataDescriptor(Desc)) { + if (!hasOwn(Desc, '[[Value]]')) { + Desc['[[Value]]'] = void 0; + } + if (!hasOwn(Desc, '[[Writable]]')) { + Desc['[[Writable]]'] = false; + } + } else { + if (!hasOwn(Desc, '[[Get]]')) { + Desc['[[Get]]'] = void 0; + } + if (!hasOwn(Desc, '[[Set]]')) { + Desc['[[Set]]'] = void 0; + } + } + if (!hasOwn(Desc, '[[Enumerable]]')) { + Desc['[[Enumerable]]'] = false; + } + if (!hasOwn(Desc, '[[Configurable]]')) { + Desc['[[Configurable]]'] = false; + } + return Desc; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CompletionRecord.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CompletionRecord.js new file mode 100644 index 0000000000000000000000000000000000000000..0a7a6817c87e69578cfbc5546901b1c4dba112a9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CompletionRecord.js @@ -0,0 +1,48 @@ +'use strict'; + +var $SyntaxError = require('es-errors/syntax'); + +var SLOT = require('internal-slot'); + +// https://262.ecma-international.org/7.0/#sec-completion-record-specification-type + +var CompletionRecord = function CompletionRecord(type, value) { + if (!(this instanceof CompletionRecord)) { + return new CompletionRecord(type, value); + } + if (type !== 'normal' && type !== 'break' && type !== 'continue' && type !== 'return' && type !== 'throw') { + throw new $SyntaxError('Assertion failed: `type` must be one of "normal", "break", "continue", "return", or "throw"'); + } + SLOT.set(this, '[[Type]]', type); + SLOT.set(this, '[[Value]]', value); + // [[Target]] slot? +}; + +CompletionRecord.prototype.type = function Type() { + return SLOT.get(this, '[[Type]]'); +}; + +CompletionRecord.prototype.value = function Value() { + return SLOT.get(this, '[[Value]]'); +}; + +CompletionRecord.prototype['?'] = function ReturnIfAbrupt() { + var type = SLOT.get(this, '[[Type]]'); + var value = SLOT.get(this, '[[Value]]'); + + if (type === 'throw') { + throw value; + } + return value; +}; + +CompletionRecord.prototype['!'] = function assert() { + var type = SLOT.get(this, '[[Type]]'); + + if (type !== 'normal') { + throw new $SyntaxError('Assertion failed: Completion Record is not of type "normal"'); + } + return SLOT.get(this, '[[Value]]'); +}; + +module.exports = CompletionRecord; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CreateDataProperty.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CreateDataProperty.js new file mode 100644 index 0000000000000000000000000000000000000000..897617c0ca1e0365cb55a83855b0983550e3e298 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CreateDataProperty.js @@ -0,0 +1,25 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var isPropertyKey = require('../helpers/isPropertyKey'); +var OrdinaryDefineOwnProperty = require('./OrdinaryDefineOwnProperty'); + +// https://262.ecma-international.org/6.0/#sec-createdataproperty + +module.exports = function CreateDataProperty(O, P, V) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: Type(O) is not Object'); + } + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: P is not a Property Key'); + } + var newDesc = { + '[[Configurable]]': true, + '[[Enumerable]]': true, + '[[Value]]': V, + '[[Writable]]': true + }; + return OrdinaryDefineOwnProperty(O, P, newDesc); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CreateDataPropertyOrThrow.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CreateDataPropertyOrThrow.js new file mode 100644 index 0000000000000000000000000000000000000000..42327aaef58a8ffc3c320851135e886106dcbad6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CreateDataPropertyOrThrow.js @@ -0,0 +1,24 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var CreateDataProperty = require('./CreateDataProperty'); + +var isPropertyKey = require('../helpers/isPropertyKey'); + +// // https://262.ecma-international.org/6.0/#sec-createdatapropertyorthrow + +module.exports = function CreateDataPropertyOrThrow(O, P, V) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: Type(O) is not Object'); + } + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: P is not a Property Key'); + } + var success = CreateDataProperty(O, P, V); + if (!success) { + throw new $TypeError('unable to create data property'); + } + return success; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CreateHTML.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CreateHTML.js new file mode 100644 index 0000000000000000000000000000000000000000..25630f43085954792b398e93a870ac78b46e3fc4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CreateHTML.js @@ -0,0 +1,27 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var callBound = require('call-bound'); + +var $replace = callBound('String.prototype.replace'); + +var RequireObjectCoercible = require('./RequireObjectCoercible'); +var ToString = require('./ToString'); + +// https://262.ecma-international.org/6.0/#sec-createhtml + +module.exports = function CreateHTML(string, tag, attribute, value) { + if (typeof tag !== 'string' || typeof attribute !== 'string') { + throw new $TypeError('Assertion failed: `tag` and `attribute` must be strings'); + } + var str = RequireObjectCoercible(string); + var S = ToString(str); + var p1 = '<' + tag; + if (attribute !== '') { + var V = ToString(value); + var escapedV = $replace(V, /\x22/g, '"'); + p1 += '\x20' + attribute + '\x3D\x22' + escapedV + '\x22'; + } + return p1 + '>' + S + ''; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CreateIterResultObject.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CreateIterResultObject.js new file mode 100644 index 0000000000000000000000000000000000000000..679bdf00ea851b40cce0dc9e6d55526aa9d5c5d7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CreateIterResultObject.js @@ -0,0 +1,15 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +// https://262.ecma-international.org/6.0/#sec-createiterresultobject + +module.exports = function CreateIterResultObject(value, done) { + if (typeof done !== 'boolean') { + throw new $TypeError('Assertion failed: Type(done) is not Boolean'); + } + return { + value: value, + done: done + }; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CreateListFromArrayLike.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CreateListFromArrayLike.js new file mode 100644 index 0000000000000000000000000000000000000000..229f215c4db64cd944b0b646b7545eeac965f55b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CreateListFromArrayLike.js @@ -0,0 +1,43 @@ +'use strict'; + +var callBound = require('call-bound'); + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); +var $indexOf = callBound('Array.prototype.indexOf', true) || callBound('String.prototype.indexOf'); + +var Get = require('./Get'); +var IsArray = require('./IsArray'); +var ToLength = require('./ToLength'); +var ToString = require('./ToString'); +var Type = require('./Type'); + +var defaultElementTypes = ['Undefined', 'Null', 'Boolean', 'String', 'Symbol', 'Number', 'Object']; + +// https://262.ecma-international.org/6.0/#sec-createlistfromarraylike +module.exports = function CreateListFromArrayLike(obj) { + var elementTypes = arguments.length > 1 + ? arguments[1] + : defaultElementTypes; + + if (!isObject(obj)) { + throw new $TypeError('Assertion failed: `obj` must be an Object'); + } + if (!IsArray(elementTypes)) { + throw new $TypeError('Assertion failed: `elementTypes`, if provided, must be an array'); + } + var len = ToLength(Get(obj, 'length')); + var list = []; + var index = 0; + while (index < len) { + var indexName = ToString(index); + var next = Get(obj, indexName); + var nextType = Type(next); + if ($indexOf(elementTypes, nextType) < 0) { + throw new $TypeError('item type ' + nextType + ' is not a valid elementType'); + } + list[list.length] = next; + index += 1; + } + return list; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CreateMethodProperty.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CreateMethodProperty.js new file mode 100644 index 0000000000000000000000000000000000000000..4c53a40986ad2c0f6678b161465bca1ba569dd21 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/CreateMethodProperty.js @@ -0,0 +1,38 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var DefineOwnProperty = require('../helpers/DefineOwnProperty'); + +var FromPropertyDescriptor = require('./FromPropertyDescriptor'); +var IsDataDescriptor = require('./IsDataDescriptor'); +var isPropertyKey = require('../helpers/isPropertyKey'); +var SameValue = require('./SameValue'); + +// https://262.ecma-international.org/6.0/#sec-createmethodproperty + +module.exports = function CreateMethodProperty(O, P, V) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: Type(O) is not Object'); + } + + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: P is not a Property Key'); + } + + var newDesc = { + '[[Configurable]]': true, + '[[Enumerable]]': false, + '[[Value]]': V, + '[[Writable]]': true + }; + return DefineOwnProperty( + IsDataDescriptor, + SameValue, + FromPropertyDescriptor, + O, + P, + newDesc + ); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/DateFromTime.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/DateFromTime.js new file mode 100644 index 0000000000000000000000000000000000000000..ec7edcd295f8bdd79eb60e44d8a17bb0b90fd80d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/DateFromTime.js @@ -0,0 +1,52 @@ +'use strict'; + +var $EvalError = require('es-errors/eval'); + +var DayWithinYear = require('./DayWithinYear'); +var InLeapYear = require('./InLeapYear'); +var MonthFromTime = require('./MonthFromTime'); + +// https://262.ecma-international.org/5.1/#sec-15.9.1.5 + +module.exports = function DateFromTime(t) { + var m = MonthFromTime(t); + var d = DayWithinYear(t); + if (m === 0) { + return d + 1; + } + if (m === 1) { + return d - 30; + } + var leap = InLeapYear(t); + if (m === 2) { + return d - 58 - leap; + } + if (m === 3) { + return d - 89 - leap; + } + if (m === 4) { + return d - 119 - leap; + } + if (m === 5) { + return d - 150 - leap; + } + if (m === 6) { + return d - 180 - leap; + } + if (m === 7) { + return d - 211 - leap; + } + if (m === 8) { + return d - 242 - leap; + } + if (m === 9) { + return d - 272 - leap; + } + if (m === 10) { + return d - 303 - leap; + } + if (m === 11) { + return d - 333 - leap; + } + throw new $EvalError('Assertion failed: MonthFromTime returned an impossible value: ' + m); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/Day.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/Day.js new file mode 100644 index 0000000000000000000000000000000000000000..51d01033c81cbd356ff4da8010c166137364237d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/Day.js @@ -0,0 +1,11 @@ +'use strict'; + +var floor = require('./floor'); + +var msPerDay = require('../helpers/timeConstants').msPerDay; + +// https://262.ecma-international.org/5.1/#sec-15.9.1.2 + +module.exports = function Day(t) { + return floor(t / msPerDay); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/DayFromYear.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/DayFromYear.js new file mode 100644 index 0000000000000000000000000000000000000000..341bf22a6c19352ec6225944fb49adeed22983e8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/DayFromYear.js @@ -0,0 +1,10 @@ +'use strict'; + +var floor = require('./floor'); + +// https://262.ecma-international.org/5.1/#sec-15.9.1.3 + +module.exports = function DayFromYear(y) { + return (365 * (y - 1970)) + floor((y - 1969) / 4) - floor((y - 1901) / 100) + floor((y - 1601) / 400); +}; + diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/DayWithinYear.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/DayWithinYear.js new file mode 100644 index 0000000000000000000000000000000000000000..4c580940a58c58dcc3f7c2f96c5bca8e8237ebfc --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/DayWithinYear.js @@ -0,0 +1,11 @@ +'use strict'; + +var Day = require('./Day'); +var DayFromYear = require('./DayFromYear'); +var YearFromTime = require('./YearFromTime'); + +// https://262.ecma-international.org/5.1/#sec-15.9.1.4 + +module.exports = function DayWithinYear(t) { + return Day(t) - DayFromYear(YearFromTime(t)); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/DaysInYear.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/DaysInYear.js new file mode 100644 index 0000000000000000000000000000000000000000..7116c69027022323e41130f384db7cc3d35709f9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/DaysInYear.js @@ -0,0 +1,18 @@ +'use strict'; + +var modulo = require('./modulo'); + +// https://262.ecma-international.org/5.1/#sec-15.9.1.3 + +module.exports = function DaysInYear(y) { + if (modulo(y, 4) !== 0) { + return 365; + } + if (modulo(y, 100) !== 0) { + return 366; + } + if (modulo(y, 400) !== 0) { + return 365; + } + return 366; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/DefinePropertyOrThrow.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/DefinePropertyOrThrow.js new file mode 100644 index 0000000000000000000000000000000000000000..ff6683c3dc954ec27c072032bfcc0cfd70936587 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/DefinePropertyOrThrow.js @@ -0,0 +1,39 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var isPropertyDescriptor = require('../helpers/records/property-descriptor'); +var DefineOwnProperty = require('../helpers/DefineOwnProperty'); + +var FromPropertyDescriptor = require('./FromPropertyDescriptor'); +var IsDataDescriptor = require('./IsDataDescriptor'); +var isPropertyKey = require('../helpers/isPropertyKey'); +var SameValue = require('./SameValue'); +var ToPropertyDescriptor = require('./ToPropertyDescriptor'); + +// https://262.ecma-international.org/6.0/#sec-definepropertyorthrow + +module.exports = function DefinePropertyOrThrow(O, P, desc) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: Type(O) is not Object'); + } + + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: P is not a Property Key'); + } + + var Desc = isPropertyDescriptor(desc) ? desc : ToPropertyDescriptor(desc); + if (!isPropertyDescriptor(Desc)) { + throw new $TypeError('Assertion failed: Desc is not a valid Property Descriptor'); + } + + return DefineOwnProperty( + IsDataDescriptor, + SameValue, + FromPropertyDescriptor, + O, + P, + Desc + ); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/DeletePropertyOrThrow.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/DeletePropertyOrThrow.js new file mode 100644 index 0000000000000000000000000000000000000000..8841fda81f7663673367bdfc1af99794fb0ef747 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/DeletePropertyOrThrow.js @@ -0,0 +1,25 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var isPropertyKey = require('../helpers/isPropertyKey'); + +// https://262.ecma-international.org/6.0/#sec-deletepropertyorthrow + +module.exports = function DeletePropertyOrThrow(O, P) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: Type(O) is not Object'); + } + + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: P is not a Property Key'); + } + + // eslint-disable-next-line no-param-reassign + var success = delete O[P]; + if (!success) { + throw new $TypeError('Attempt to delete property failed.'); + } + return success; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/DetachArrayBuffer.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/DetachArrayBuffer.js new file mode 100644 index 0000000000000000000000000000000000000000..00639640cbf8177dc231ff439d56da0387ebb275 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/DetachArrayBuffer.js @@ -0,0 +1,38 @@ +'use strict'; + +var $SyntaxError = require('es-errors/syntax'); +var $TypeError = require('es-errors/type'); + +var isArrayBuffer = require('is-array-buffer'); + +var IsDetachedBuffer = require('./IsDetachedBuffer'); + +var MessageChannel; +try { + // eslint-disable-next-line global-require + MessageChannel = require('worker_threads').MessageChannel; // node 11.7+ +} catch (e) { /**/ } + +// https://262.ecma-international.org/6.0/#sec-detacharraybuffer + +/* globals postMessage */ + +module.exports = function DetachArrayBuffer(arrayBuffer) { + if (!isArrayBuffer(arrayBuffer)) { + throw new $TypeError('Assertion failed: `arrayBuffer` must be an Object with an [[ArrayBufferData]] internal slot'); + } + + if (!IsDetachedBuffer(arrayBuffer)) { // node v21.0.0+ throws when you structuredClone a detached buffer + if (typeof structuredClone === 'function') { + structuredClone(arrayBuffer, { transfer: [arrayBuffer] }); + } else if (typeof postMessage === 'function') { + postMessage('', '/', [arrayBuffer]); // TODO: see if this might trigger listeners + } else if (MessageChannel) { + (new MessageChannel()).port1.postMessage(null, [arrayBuffer]); + } else { + throw new $SyntaxError('DetachArrayBuffer is not supported in this environment'); + } + } + + return null; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/EnumerableOwnNames.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/EnumerableOwnNames.js new file mode 100644 index 0000000000000000000000000000000000000000..aaac4bbef6da25ac79c7a0836544b768decd8de7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/EnumerableOwnNames.js @@ -0,0 +1,16 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var keys = require('object-keys'); + +// https://262.ecma-international.org/6.0/#sec-enumerableownnames + +module.exports = function EnumerableOwnNames(O) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: Type(O) is not Object'); + } + + return keys(O); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/FromPropertyDescriptor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/FromPropertyDescriptor.js new file mode 100644 index 0000000000000000000000000000000000000000..45b6379f1214c415e1e43b855db01f18b3566cba --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/FromPropertyDescriptor.js @@ -0,0 +1,16 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var isPropertyDescriptor = require('../helpers/records/property-descriptor'); +var fromPropertyDescriptor = require('../helpers/fromPropertyDescriptor'); + +// https://262.ecma-international.org/6.0/#sec-frompropertydescriptor + +module.exports = function FromPropertyDescriptor(Desc) { + if (typeof Desc !== 'undefined' && !isPropertyDescriptor(Desc)) { + throw new $TypeError('Assertion failed: `Desc` must be a Property Descriptor'); + } + + return fromPropertyDescriptor(Desc); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/Get.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/Get.js new file mode 100644 index 0000000000000000000000000000000000000000..42f7a14d853e05735d4166708590df2743cfa74c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/Get.js @@ -0,0 +1,24 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var inspect = require('object-inspect'); + +var isPropertyKey = require('../helpers/isPropertyKey'); + +var isObject = require('es-object-atoms/isObject'); + +// https://262.ecma-international.org/6.0/#sec-get-o-p + +module.exports = function Get(O, P) { + // 7.3.1.1 + if (!isObject(O)) { + throw new $TypeError('Assertion failed: Type(O) is not Object'); + } + // 7.3.1.2 + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: P is not a Property Key, got ' + inspect(P)); + } + // 7.3.1.3 + return O[P]; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/GetGlobalObject.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/GetGlobalObject.js new file mode 100644 index 0000000000000000000000000000000000000000..0541ede0c48889fefe9a137e0e37a2e13573c091 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/GetGlobalObject.js @@ -0,0 +1,9 @@ +'use strict'; + +var getGlobal = require('globalthis/polyfill'); + +// https://262.ecma-international.org/6.0/#sec-getglobalobject + +module.exports = function GetGlobalObject() { + return getGlobal(); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/GetIterator.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/GetIterator.js new file mode 100644 index 0000000000000000000000000000000000000000..1a8d49a686fdb4ae3b9edb87f3dce6a9815565ab --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/GetIterator.js @@ -0,0 +1,30 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var getIteratorMethod = require('../helpers/getIteratorMethod'); +var AdvanceStringIndex = require('./AdvanceStringIndex'); +var Call = require('./Call'); +var GetMethod = require('./GetMethod'); + +var isObject = require('es-object-atoms/isObject'); + +var ES = { + AdvanceStringIndex: AdvanceStringIndex, + GetMethod: GetMethod +}; + +// https://262.ecma-international.org/6.0/#sec-getiterator + +module.exports = function GetIterator(obj, method) { + var actualMethod = method; + if (arguments.length < 2) { + actualMethod = getIteratorMethod(ES, obj); + } + var iterator = Call(actualMethod, obj); + if (!isObject(iterator)) { + throw new $TypeError('iterator must return an object'); + } + + return iterator; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/GetMethod.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/GetMethod.js new file mode 100644 index 0000000000000000000000000000000000000000..e28bb1501fc8e4d4a67250c5110cba73bbcba385 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/GetMethod.js @@ -0,0 +1,34 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var GetV = require('./GetV'); +var IsCallable = require('./IsCallable'); +var isPropertyKey = require('../helpers/isPropertyKey'); + +var inspect = require('object-inspect'); + +// https://262.ecma-international.org/6.0/#sec-getmethod + +module.exports = function GetMethod(O, P) { + // 7.3.9.1 + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: P is not a Property Key'); + } + + // 7.3.9.2 + var func = GetV(O, P); + + // 7.3.9.4 + if (func == null) { + return void 0; + } + + // 7.3.9.5 + if (!IsCallable(func)) { + throw new $TypeError(inspect(P) + ' is not a function: ' + inspect(func)); + } + + // 7.3.9.6 + return func; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/GetOwnPropertyKeys.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/GetOwnPropertyKeys.js new file mode 100644 index 0000000000000000000000000000000000000000..e9b50d744a5fdf42221ad18e6674e777fa3b0a47 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/GetOwnPropertyKeys.js @@ -0,0 +1,30 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var hasSymbols = require('has-symbols')(); + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var $gOPN = GetIntrinsic('%Object.getOwnPropertyNames%', true); +var $gOPS = hasSymbols && GetIntrinsic('%Object.getOwnPropertySymbols%', true); +var keys = require('object-keys'); + +// https://262.ecma-international.org/6.0/#sec-getownpropertykeys + +module.exports = function GetOwnPropertyKeys(O, Type) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: Type(O) is not Object'); + } + if (Type === 'Symbol') { + return $gOPS ? $gOPS(O) : []; + } + if (Type === 'String') { + if (!$gOPN) { + return keys(O); + } + return $gOPN(O); + } + throw new $TypeError('Assertion failed: `Type` must be `"String"` or `"Symbol"`'); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/GetPrototypeFromConstructor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/GetPrototypeFromConstructor.js new file mode 100644 index 0000000000000000000000000000000000000000..687f6ef200fb11a3dc97a27533d15430c305fb3b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/GetPrototypeFromConstructor.js @@ -0,0 +1,33 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $Function = GetIntrinsic('%Function%'); +var $TypeError = require('es-errors/type'); +var $SyntaxError = require('es-errors/syntax'); + +var Get = require('./Get'); +var IsConstructor = require('./IsConstructor'); + +var isObject = require('es-object-atoms/isObject'); + +// https://262.ecma-international.org/6.0/#sec-getprototypefromconstructor + +module.exports = function GetPrototypeFromConstructor(constructor, intrinsicDefaultProto) { + var intrinsic = GetIntrinsic(intrinsicDefaultProto); // throws if not a valid intrinsic + if (!isObject(intrinsic)) { + throw new $TypeError('intrinsicDefaultProto must be an object'); + } + if (!IsConstructor(constructor)) { + throw new $TypeError('Assertion failed: `constructor` must be a constructor'); + } + var proto = Get(constructor, 'prototype'); + if (!isObject(proto)) { + if (!(constructor instanceof $Function)) { + // ignore other realms, for now + throw new $SyntaxError('cross-realm constructors not currently supported'); + } + proto = intrinsic; + } + return proto; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/GetSubstitution.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/GetSubstitution.js new file mode 100644 index 0000000000000000000000000000000000000000..13cd94ad863d4ae766025ebc687bd6628666e637 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/GetSubstitution.js @@ -0,0 +1,98 @@ + +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $TypeError = require('es-errors/type'); +var $parseInt = GetIntrinsic('%parseInt%'); + +var inspect = require('object-inspect'); +var isInteger = require('math-intrinsics/isInteger'); +var regexTester = require('safe-regex-test'); +var callBound = require('call-bound'); +var every = require('../helpers/every'); + +var isDigit = regexTester(/^[0-9]$/); + +var $charAt = callBound('String.prototype.charAt'); +var $strSlice = callBound('String.prototype.slice'); + +var IsArray = require('./IsArray'); + +var isStringOrUndefined = require('../helpers/isStringOrUndefined'); + +// https://262.ecma-international.org/6.0/#sec-getsubstitution + +// eslint-disable-next-line max-statements, max-lines-per-function +module.exports = function GetSubstitution(matched, str, position, captures, replacement) { + if (typeof matched !== 'string') { + throw new $TypeError('Assertion failed: `matched` must be a String'); + } + var matchLength = matched.length; + + if (typeof str !== 'string') { + throw new $TypeError('Assertion failed: `str` must be a String'); + } + var stringLength = str.length; + + if (!isInteger(position) || position < 0 || position > stringLength) { + throw new $TypeError('Assertion failed: `position` must be a nonnegative integer, and less than or equal to the length of `string`, got ' + inspect(position)); + } + + if (!IsArray(captures) || !every(captures, isStringOrUndefined)) { + throw new $TypeError('Assertion failed: `captures` must be a List of Strings, got ' + inspect(captures)); + } + + if (typeof replacement !== 'string') { + throw new $TypeError('Assertion failed: `replacement` must be a String'); + } + + var tailPos = position + matchLength; + var m = captures.length; + + var result = ''; + for (var i = 0; i < replacement.length; i += 1) { + // if this is a $, and it's not the end of the replacement + var current = $charAt(replacement, i); + var isLast = (i + 1) >= replacement.length; + var nextIsLast = (i + 2) >= replacement.length; + if (current === '$' && !isLast) { + var next = $charAt(replacement, i + 1); + if (next === '$') { + result += '$'; + i += 1; + } else if (next === '&') { + result += matched; + i += 1; + } else if (next === '`') { + result += position === 0 ? '' : $strSlice(str, 0, position - 1); + i += 1; + } else if (next === "'") { + result += tailPos >= stringLength ? '' : $strSlice(str, tailPos); + i += 1; + } else { + var nextNext = nextIsLast ? null : $charAt(replacement, i + 2); + if (isDigit(next) && next !== '0' && (nextIsLast || !isDigit(nextNext))) { + // $1 through $9, and not followed by a digit + var n = $parseInt(next, 10); + // if (n > m, impl-defined) + result += n <= m && typeof captures[n - 1] === 'undefined' ? '' : captures[n - 1]; + i += 1; + } else if (isDigit(next) && (nextIsLast || isDigit(nextNext))) { + // $00 through $99 + var nn = next + nextNext; + var nnI = $parseInt(nn, 10) - 1; + // if nn === '00' or nn > m, impl-defined + result += nn <= m && typeof captures[nnI] === 'undefined' ? '' : captures[nnI]; + i += 2; + } else { + result += '$'; + } + } + } else { + // the final $, or else not a $ + result += $charAt(replacement, i); + } + } + return result; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/GetV.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/GetV.js new file mode 100644 index 0000000000000000000000000000000000000000..920dec3c4a4eac8aa63678c2afa5683e79e3337f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/GetV.js @@ -0,0 +1,23 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var inspect = require('object-inspect'); + +var isPropertyKey = require('../helpers/isPropertyKey'); +// var ToObject = require('./ToObject'); + +// https://262.ecma-international.org/6.0/#sec-getv + +module.exports = function GetV(V, P) { + // 7.3.2.1 + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: P is not a Property Key, got ' + inspect(P)); + } + + // 7.3.2.2-3 + // var O = ToObject(V); + + // 7.3.2.4 + return V[P]; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/GetValueFromBuffer.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/GetValueFromBuffer.js new file mode 100644 index 0000000000000000000000000000000000000000..893929edbc56f4d6b6340295f91e2d24cc82ad4c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/GetValueFromBuffer.js @@ -0,0 +1,86 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $TypeError = require('es-errors/type'); +var $Uint8Array = GetIntrinsic('%Uint8Array%', true); + +var isInteger = require('math-intrinsics/isInteger'); +var callBound = require('call-bound'); + +var $charAt = callBound('String.prototype.charAt'); +var $reverse = callBound('Array.prototype.reverse'); +var $slice = callBound('Array.prototype.slice'); + +var bytesAsFloat32 = require('../helpers/bytesAsFloat32'); +var bytesAsFloat64 = require('../helpers/bytesAsFloat64'); +var bytesAsInteger = require('../helpers/bytesAsInteger'); +var defaultEndianness = require('../helpers/defaultEndianness'); + +var IsDetachedBuffer = require('./IsDetachedBuffer'); + +var isArrayBuffer = require('is-array-buffer'); +var safeConcat = require('safe-array-concat'); + +var tableTAO = require('./tables/typed-array-objects'); + +var isUnsignedElementType = function isUnsignedElementType(type) { return $charAt(type, 0) === 'U'; }; + +// https://262.ecma-international.org/6.0/#sec-getvaluefrombuffer + +module.exports = function GetValueFromBuffer(arrayBuffer, byteIndex, type) { + if (!isArrayBuffer(arrayBuffer)) { + throw new $TypeError('Assertion failed: `arrayBuffer` must be an ArrayBuffer'); + } + + if (!isInteger(byteIndex)) { + throw new $TypeError('Assertion failed: `byteIndex` must be an integer'); + } + + if (typeof type !== 'string') { + throw new $TypeError('Assertion failed: `type` must be a string'); + } + + if (arguments.length > 3 && typeof arguments[3] !== 'boolean') { + throw new $TypeError('Assertion failed: `isLittleEndian` must be a boolean, if present'); + } + + if (IsDetachedBuffer(arrayBuffer)) { + throw new $TypeError('Assertion failed: ArrayBuffer is detached'); // step 1 + } + + // 2. Assert: There are sufficient bytes in arrayBuffer starting at byteIndex to represent a value of type. + + if (byteIndex < 0) { + throw new $TypeError('Assertion failed: `byteIndex` must be non-negative'); // step 3 + } + + // 4. Let block be arrayBuffer’s [[ArrayBufferData]] internal slot. + + var elementSize = tableTAO.size['$' + type]; // step 5 + if (!elementSize) { + throw new $TypeError('Assertion failed: `type` must be one of ' + tableTAO.choices); + } + + // 6. Let rawValue be a List of elementSize containing, in order, the elementSize sequence of bytes starting with block[byteIndex]. + var rawValue = $slice(new $Uint8Array(arrayBuffer, byteIndex), 0, elementSize); // step 6 + + // 8. If isLittleEndian is not present, set isLittleEndian to either true or false. The choice is implementation dependent and should be the alternative that is most efficient for the implementation. An implementation must use the same value each time this step is executed and the same value must be used for the corresponding step in the SetValueInBuffer abstract operation. + var isLittleEndian = arguments.length > 3 ? arguments[3] : defaultEndianness === 'little'; // step 7 + + if (!isLittleEndian) { + $reverse(rawValue); // step 8 + } + + var bytes = $slice(safeConcat([0, 0, 0, 0, 0, 0, 0, 0], rawValue), -elementSize); + + if (type === 'Float32') { // step 3 + return bytesAsFloat32(bytes); + } + + if (type === 'Float64') { // step 4 + return bytesAsFloat64(bytes); + } + + return bytesAsInteger(bytes, elementSize, isUnsignedElementType(type), false); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/HasOwnProperty.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/HasOwnProperty.js new file mode 100644 index 0000000000000000000000000000000000000000..617f0b856e81f2518d2c03bf72b367eea50eb6ef --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/HasOwnProperty.js @@ -0,0 +1,20 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var hasOwn = require('hasown'); +var isObject = require('es-object-atoms/isObject'); + +var isPropertyKey = require('../helpers/isPropertyKey'); + +// https://262.ecma-international.org/6.0/#sec-hasownproperty + +module.exports = function HasOwnProperty(O, P) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: `O` must be an Object'); + } + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: `P` must be a Property Key'); + } + return hasOwn(O, P); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/HasProperty.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/HasProperty.js new file mode 100644 index 0000000000000000000000000000000000000000..eb66ca9853ec09c092d87f10333fcdb19a882c83 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/HasProperty.js @@ -0,0 +1,18 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var isPropertyKey = require('../helpers/isPropertyKey'); + +// https://262.ecma-international.org/6.0/#sec-hasproperty + +module.exports = function HasProperty(O, P) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: `O` must be an Object'); + } + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: `P` must be a Property Key'); + } + return P in O; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/HourFromTime.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/HourFromTime.js new file mode 100644 index 0000000000000000000000000000000000000000..f963bfb68540ba21f46be00b623cb89db98d63f5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/HourFromTime.js @@ -0,0 +1,14 @@ +'use strict'; + +var floor = require('./floor'); +var modulo = require('./modulo'); + +var timeConstants = require('../helpers/timeConstants'); +var msPerHour = timeConstants.msPerHour; +var HoursPerDay = timeConstants.HoursPerDay; + +// https://262.ecma-international.org/5.1/#sec-15.9.1.10 + +module.exports = function HourFromTime(t) { + return modulo(floor(t / msPerHour), HoursPerDay); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/InLeapYear.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/InLeapYear.js new file mode 100644 index 0000000000000000000000000000000000000000..4a283a4b6097f4b2c4e872b0cc775024ff517b77 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/InLeapYear.js @@ -0,0 +1,19 @@ +'use strict'; + +var $EvalError = require('es-errors/eval'); + +var DaysInYear = require('./DaysInYear'); +var YearFromTime = require('./YearFromTime'); + +// https://262.ecma-international.org/5.1/#sec-15.9.1.3 + +module.exports = function InLeapYear(t) { + var days = DaysInYear(YearFromTime(t)); + if (days === 365) { + return 0; + } + if (days === 366) { + return 1; + } + throw new $EvalError('Assertion failed: there are not 365 or 366 days in a year, got: ' + days); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/InstanceofOperator.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/InstanceofOperator.js new file mode 100644 index 0000000000000000000000000000000000000000..5dd7d04a4c16b423b1613070585b864e22b2dc9e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/InstanceofOperator.js @@ -0,0 +1,30 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var $hasInstance = GetIntrinsic('%Symbol.hasInstance%', true); + +var Call = require('./Call'); +var GetMethod = require('./GetMethod'); +var IsCallable = require('./IsCallable'); +var OrdinaryHasInstance = require('./OrdinaryHasInstance'); +var ToBoolean = require('./ToBoolean'); + +// https://262.ecma-international.org/6.0/#sec-instanceofoperator + +module.exports = function InstanceofOperator(O, C) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: Type(O) is not Object'); + } + var instOfHandler = $hasInstance ? GetMethod(C, $hasInstance) : void 0; + if (typeof instOfHandler !== 'undefined') { + return ToBoolean(Call(instOfHandler, C, [O])); + } + if (!IsCallable(C)) { + throw new $TypeError('`C` is not Callable'); + } + return OrdinaryHasInstance(C, O); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IntegerIndexedElementGet.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IntegerIndexedElementGet.js new file mode 100644 index 0000000000000000000000000000000000000000..796ea2c3d5038fbe6080ad123426eeb585917fab --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IntegerIndexedElementGet.js @@ -0,0 +1,57 @@ +'use strict'; + +var $SyntaxError = require('es-errors/syntax'); +var $TypeError = require('es-errors/type'); +var isNegativeZero = require('math-intrinsics/isNegativeZero'); + +var GetValueFromBuffer = require('./GetValueFromBuffer'); +var IsDetachedBuffer = require('./IsDetachedBuffer'); +var IsInteger = require('./IsInteger'); + +var typedArrayLength = require('typed-array-length'); +var typedArrayBuffer = require('typed-array-buffer'); +var typedArrayByteOffset = require('typed-array-byte-offset'); +var whichTypedArray = require('which-typed-array'); + +var tableTAO = require('./tables/typed-array-objects'); + +// https://262.ecma-international.org/6.0/#sec-integerindexedelementget + +module.exports = function IntegerIndexedElementGet(O, index) { + if (typeof index !== 'number') { + throw new $TypeError('`index` must be a Number'); // step 1 + } + var arrayTypeName = whichTypedArray(O); // step 10 + if (!arrayTypeName) { + throw new $TypeError('`O` must be a TypedArray'); // step 2 + } + if (arrayTypeName === 'BigInt64Array' || arrayTypeName === 'BigUint64Array') { + throw new $SyntaxError('BigInt64Array and BigUint64Array do not exist until ES2020'); + } + + var buffer = typedArrayBuffer(O); // step 3 + + if (IsDetachedBuffer(buffer)) { + throw new $TypeError('`O` has a detached buffer'); // step 4 + } + + if (!IsInteger(index) || isNegativeZero(index)) { + return void undefined; // steps 5 - 6 + } + + var length = typedArrayLength(O); // step 7 + + if (index < 0 || index >= length) { + return void undefined; // step 8 + } + + var offset = typedArrayByteOffset(O); // step 9 + + var elementType = tableTAO.name['$' + arrayTypeName]; // step 13 + + var elementSize = tableTAO.size['$' + elementType]; // step 11 + + var indexedPosition = (index * elementSize) + offset; // step 12 + + return GetValueFromBuffer(buffer, indexedPosition, elementType); // step 14 +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IntegerIndexedElementSet.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IntegerIndexedElementSet.js new file mode 100644 index 0000000000000000000000000000000000000000..908e0a979ad5cf50cb02afa2e35f6cf807884319 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IntegerIndexedElementSet.js @@ -0,0 +1,62 @@ +'use strict'; + +var $SyntaxError = require('es-errors/syntax'); +var $TypeError = require('es-errors/type'); + +var IsDetachedBuffer = require('./IsDetachedBuffer'); +var IsInteger = require('./IsInteger'); +var SetValueInBuffer = require('./SetValueInBuffer'); +var ToNumber = require('./ToNumber'); + +var isNegativeZero = require('math-intrinsics/isNegativeZero'); +var typedArrayBuffer = require('typed-array-buffer'); +var typedArrayByteOffset = require('typed-array-byte-offset'); +var typedArrayLength = require('typed-array-length'); +var whichTypedArray = require('which-typed-array'); + +var tableTAO = require('./tables/typed-array-objects'); + +// https://262.ecma-international.org/6.0/#sec-integerindexedelementset + +module.exports = function IntegerIndexedElementSet(O, index, value) { + if (typeof index !== 'number') { + throw new $TypeError('`index` must be a Number'); // step 1 + } + var arrayTypeName = whichTypedArray(O); // step 12 + if (!arrayTypeName) { + throw new $TypeError('`O` must be a TypedArray'); // step 2 + } + if (arrayTypeName === 'BigInt64Array' || arrayTypeName === 'BigUint64Array') { + throw new $SyntaxError('BigInt64Array and BigUint64Array do not exist until ES2020'); // step 2 + } + + var numValue = ToNumber(value); // step 3 + + var buffer = typedArrayBuffer(O); // step 5 + + if (IsDetachedBuffer(buffer)) { + throw new $TypeError('`O` has a detached buffer'); // step 6 + } + + if (!IsInteger(index) || isNegativeZero(index)) { + return false; // steps 7 - 8 + } + + var length = typedArrayLength(O); // step 9 + + if (index < 0 || index >= length) { + return false; // step 10 + } + + var offset = typedArrayByteOffset(O); // step 11 + + var elementType = tableTAO.name['$' + arrayTypeName]; // step 15 + + var elementSize = tableTAO.size['$' + elementType]; // step 13 + + var indexedPosition = (index * elementSize) + offset; // step 14 + + SetValueInBuffer(buffer, indexedPosition, elementType, numValue); // step 16 + + return true; // step 17 +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/InternalizeJSONProperty.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/InternalizeJSONProperty.js new file mode 100644 index 0000000000000000000000000000000000000000..6471a609d9770a8ad7d09b98b2ed7125d60a0c75 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/InternalizeJSONProperty.js @@ -0,0 +1,68 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var Call = require('./Call'); +var CreateDataProperty = require('./CreateDataProperty'); +var EnumerableOwnNames = require('./EnumerableOwnNames'); +var Get = require('./Get'); +var IsArray = require('./IsArray'); +var ToLength = require('./ToLength'); +var ToString = require('./ToString'); + +var forEach = require('../helpers/forEach'); + +// https://262.ecma-international.org/6.0/#sec-internalizejsonproperty + +// note: `reviver` was implicitly closed-over until ES2020, where it becomes a third argument + +module.exports = function InternalizeJSONProperty(holder, name, reviver) { + if (!isObject(holder)) { + throw new $TypeError('Assertion failed: `holder` is not an Object'); + } + if (typeof name !== 'string') { + throw new $TypeError('Assertion failed: `name` is not a String'); + } + if (typeof reviver !== 'function') { + throw new $TypeError('Assertion failed: `reviver` is not a Function'); + } + + var val = Get(holder, name); // step 1 + + if (isObject(val)) { // step 3 + var isArray = IsArray(val); // step 3.a + if (isArray) { // step 3.c + var I = 0; // step 3.c.i + + var len = ToLength(Get(val, 'length')); // step 3.b.ii + + while (I < len) { // step 3.b.iv + var newElement = InternalizeJSONProperty(val, ToString(I), reviver); // step 3.b.iv.1 + + if (typeof newElement === 'undefined') { // step 3.b.iv.3 + delete val[ToString(I)]; // step 3.b.iv.3.a + } else { // step 3.b.iv.4 + CreateDataProperty(val, ToString(I), newElement); // step 3.b.iv.4.a + } + + I += 1; // step 3.b.iv.6 + } + } else { + var keys = EnumerableOwnNames(val); // step 3.d.i + + forEach(keys, function (P) { // step 3.d.iii + // eslint-disable-next-line no-shadow + var newElement = InternalizeJSONProperty(val, P, reviver); // step 3.d.iii.1 + + if (typeof newElement === 'undefined') { // step 3.d.iii.3 + delete val[P]; // step 3.d.iii.3.a + } else { // step 3.d.iii.4 + CreateDataProperty(val, P, newElement); // step 3.d.iii.4.a + } + }); + } + } + + return Call(reviver, holder, [name, val]); // step 4 +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/Invoke.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/Invoke.js new file mode 100644 index 0000000000000000000000000000000000000000..57bca8ebc3dcb6172949cb3bef6f134dacabbf4b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/Invoke.js @@ -0,0 +1,22 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var Call = require('./Call'); +var IsArray = require('./IsArray'); +var GetV = require('./GetV'); +var isPropertyKey = require('../helpers/isPropertyKey'); + +// https://262.ecma-international.org/6.0/#sec-invoke + +module.exports = function Invoke(O, P) { + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: P must be a Property Key'); + } + var argumentsList = arguments.length > 2 ? arguments[2] : []; + if (!IsArray(argumentsList)) { + throw new $TypeError('Assertion failed: optional `argumentsList`, if provided, must be a List'); + } + var func = GetV(O, P); + return Call(func, O, argumentsList); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsAccessorDescriptor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsAccessorDescriptor.js new file mode 100644 index 0000000000000000000000000000000000000000..f7bf73afb1c1617b04596a6e2af6d1617857bf1e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsAccessorDescriptor.js @@ -0,0 +1,25 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var hasOwn = require('hasown'); + +var isPropertyDescriptor = require('../helpers/records/property-descriptor'); + +// https://262.ecma-international.org/5.1/#sec-8.10.1 + +module.exports = function IsAccessorDescriptor(Desc) { + if (typeof Desc === 'undefined') { + return false; + } + + if (!isPropertyDescriptor(Desc)) { + throw new $TypeError('Assertion failed: `Desc` must be a Property Descriptor'); + } + + if (!hasOwn(Desc, '[[Get]]') && !hasOwn(Desc, '[[Set]]')) { + return false; + } + + return true; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsArray.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsArray.js new file mode 100644 index 0000000000000000000000000000000000000000..c2c48c1f233c058c691d45d7587f1b58d3de5eb2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsArray.js @@ -0,0 +1,4 @@ +'use strict'; + +// https://262.ecma-international.org/6.0/#sec-isarray +module.exports = require('../helpers/IsArray'); diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsCallable.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsCallable.js new file mode 100644 index 0000000000000000000000000000000000000000..3a69b19267dff33491a84421b667a0d82cba21f9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsCallable.js @@ -0,0 +1,5 @@ +'use strict'; + +// http://262.ecma-international.org/5.1/#sec-9.11 + +module.exports = require('is-callable'); diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsCompatiblePropertyDescriptor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsCompatiblePropertyDescriptor.js new file mode 100644 index 0000000000000000000000000000000000000000..8bdaf3eb45d24407a2a416cc5aadab4f4eb1c7da --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsCompatiblePropertyDescriptor.js @@ -0,0 +1,9 @@ +'use strict'; + +var ValidateAndApplyPropertyDescriptor = require('./ValidateAndApplyPropertyDescriptor'); + +// https://262.ecma-international.org/6.0/#sec-iscompatiblepropertydescriptor + +module.exports = function IsCompatiblePropertyDescriptor(Extensible, Desc, Current) { + return ValidateAndApplyPropertyDescriptor(undefined, undefined, Extensible, Desc, Current); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsConcatSpreadable.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsConcatSpreadable.js new file mode 100644 index 0000000000000000000000000000000000000000..ace2695309292c91b185505f63da3cc942534bd2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsConcatSpreadable.js @@ -0,0 +1,26 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $isConcatSpreadable = GetIntrinsic('%Symbol.isConcatSpreadable%', true); + +var Get = require('./Get'); +var IsArray = require('./IsArray'); +var ToBoolean = require('./ToBoolean'); + +var isObject = require('es-object-atoms/isObject'); + +// https://262.ecma-international.org/6.0/#sec-isconcatspreadable + +module.exports = function IsConcatSpreadable(O) { + if (!isObject(O)) { + return false; + } + if ($isConcatSpreadable) { + var spreadable = Get(O, $isConcatSpreadable); + if (typeof spreadable !== 'undefined') { + return ToBoolean(spreadable); + } + } + return IsArray(O); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsConstructor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsConstructor.js new file mode 100644 index 0000000000000000000000000000000000000000..62ac47f6a3d262927a9b147ee0057dfba9664b24 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsConstructor.js @@ -0,0 +1,40 @@ +'use strict'; + +var GetIntrinsic = require('../GetIntrinsic.js'); + +var $construct = GetIntrinsic('%Reflect.construct%', true); + +var DefinePropertyOrThrow = require('./DefinePropertyOrThrow'); +try { + DefinePropertyOrThrow({}, '', { '[[Get]]': function () {} }); +} catch (e) { + // Accessor properties aren't supported + DefinePropertyOrThrow = null; +} + +// https://262.ecma-international.org/6.0/#sec-isconstructor + +if (DefinePropertyOrThrow && $construct) { + var isConstructorMarker = {}; + var badArrayLike = {}; + DefinePropertyOrThrow(badArrayLike, 'length', { + '[[Get]]': function () { + throw isConstructorMarker; + }, + '[[Enumerable]]': true + }); + + module.exports = function IsConstructor(argument) { + try { + // `Reflect.construct` invokes `IsConstructor(target)` before `Get(args, 'length')`: + $construct(argument, badArrayLike); + } catch (err) { + return err === isConstructorMarker; + } + }; +} else { + module.exports = function IsConstructor(argument) { + // unfortunately there's no way to truly check this without try/catch `new argument` in old environments + return typeof argument === 'function' && !!argument.prototype; + }; +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsDataDescriptor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsDataDescriptor.js new file mode 100644 index 0000000000000000000000000000000000000000..d56bd36d4294369f6486f6dfc5d60dada2cc410a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsDataDescriptor.js @@ -0,0 +1,25 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var hasOwn = require('hasown'); + +var isPropertyDescriptor = require('../helpers/records/property-descriptor'); + +// https://262.ecma-international.org/5.1/#sec-8.10.2 + +module.exports = function IsDataDescriptor(Desc) { + if (typeof Desc === 'undefined') { + return false; + } + + if (!isPropertyDescriptor(Desc)) { + throw new $TypeError('Assertion failed: `Desc` must be a Property Descriptor'); + } + + if (!hasOwn(Desc, '[[Value]]') && !hasOwn(Desc, '[[Writable]]')) { + return false; + } + + return true; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsDetachedBuffer.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsDetachedBuffer.js new file mode 100644 index 0000000000000000000000000000000000000000..afdc5c8b33948b0c78f8735c8156c81b2adb1102 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsDetachedBuffer.js @@ -0,0 +1,25 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var $byteLength = require('array-buffer-byte-length'); + +var isArrayBuffer = require('is-array-buffer'); + +var availableTypedArrays = require('available-typed-arrays')(); + +// https://262.ecma-international.org/6.0/#sec-isdetachedbuffer + +module.exports = function IsDetachedBuffer(arrayBuffer) { + if (!isArrayBuffer(arrayBuffer)) { + throw new $TypeError('Assertion failed: `arrayBuffer` must be an Object with an [[ArrayBufferData]] internal slot'); + } + if ($byteLength(arrayBuffer) === 0) { + try { + new global[availableTypedArrays[0]](arrayBuffer); // eslint-disable-line no-new + } catch (error) { + return !!error && error.name === 'TypeError'; + } + } + return false; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsExtensible.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsExtensible.js new file mode 100644 index 0000000000000000000000000000000000000000..aa19b914c2d3dc31c1215e2b203dc3ffbb78746c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsExtensible.js @@ -0,0 +1,18 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $preventExtensions = GetIntrinsic('%Object.preventExtensions%', true); +var $isExtensible = GetIntrinsic('%Object.isExtensible%', true); + +var isPrimitive = require('../helpers/isPrimitive'); + +// https://262.ecma-international.org/6.0/#sec-isextensible-o + +module.exports = $preventExtensions + ? function IsExtensible(obj) { + return !isPrimitive(obj) && $isExtensible(obj); + } + : function IsExtensible(obj) { + return !isPrimitive(obj); + }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsGenericDescriptor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsGenericDescriptor.js new file mode 100644 index 0000000000000000000000000000000000000000..9f6ef045ee44e9eaea4506a234f0e41e0bd1bac9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsGenericDescriptor.js @@ -0,0 +1,26 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var IsAccessorDescriptor = require('./IsAccessorDescriptor'); +var IsDataDescriptor = require('./IsDataDescriptor'); + +var isPropertyDescriptor = require('../helpers/records/property-descriptor'); + +// https://262.ecma-international.org/6.0/#sec-isgenericdescriptor + +module.exports = function IsGenericDescriptor(Desc) { + if (typeof Desc === 'undefined') { + return false; + } + + if (!isPropertyDescriptor(Desc)) { + throw new $TypeError('Assertion failed: `Desc` must be a Property Descriptor'); + } + + if (!IsAccessorDescriptor(Desc) && !IsDataDescriptor(Desc)) { + return true; + } + + return false; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsInteger.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsInteger.js new file mode 100644 index 0000000000000000000000000000000000000000..9acd7638f5933240e9211a985556ed27df4e82ad --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsInteger.js @@ -0,0 +1,9 @@ +'use strict'; + +var isInteger = require('math-intrinsics/isInteger'); + +// https://262.ecma-international.org/6.0/#sec-isinteger + +module.exports = function IsInteger(argument) { + return isInteger(argument); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsPromise.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsPromise.js new file mode 100644 index 0000000000000000000000000000000000000000..f3d67b1c7045d7657ec74a6d084dc088aadb5ff4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsPromise.js @@ -0,0 +1,24 @@ +'use strict'; + +var callBound = require('call-bound'); + +var $PromiseThen = callBound('Promise.prototype.then', true); + +var isObject = require('es-object-atoms/isObject'); + +// https://262.ecma-international.org/6.0/#sec-ispromise + +module.exports = function IsPromise(x) { + if (!isObject(x)) { + return false; + } + if (!$PromiseThen) { // Promises are not supported + return false; + } + try { + $PromiseThen(x); // throws if not a promise + } catch (e) { + return false; + } + return true; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsPropertyDescriptor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsPropertyDescriptor.js new file mode 100644 index 0000000000000000000000000000000000000000..d1e21ac0ec943ac40b6eaf9090b079de98feb712 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsPropertyDescriptor.js @@ -0,0 +1,11 @@ +'use strict'; + +// TODO, semver-major: delete this + +var isPropertyDescriptor = require('../helpers/records/property-descriptor'); + +// https://262.ecma-international.org/6.0/#sec-property-descriptor-specification-type + +module.exports = function IsPropertyDescriptor(Desc) { + return isPropertyDescriptor(Desc); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsPropertyKey.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsPropertyKey.js new file mode 100644 index 0000000000000000000000000000000000000000..4b1c9c71461ca474f34b517c0bc04e5d700280f2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsPropertyKey.js @@ -0,0 +1,9 @@ +'use strict'; + +var isPropertyKey = require('../helpers/isPropertyKey'); + +// https://262.ecma-international.org/6.0/#sec-ispropertykey + +module.exports = function IsPropertyKey(argument) { + return isPropertyKey(argument); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsRegExp.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsRegExp.js new file mode 100644 index 0000000000000000000000000000000000000000..8855492d58ded3c061b84be35e962fe32c8de53e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsRegExp.js @@ -0,0 +1,25 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $match = GetIntrinsic('%Symbol.match%', true); + +var hasRegExpMatcher = require('is-regex'); +var isObject = require('es-object-atoms/isObject'); + +var ToBoolean = require('./ToBoolean'); + +// https://262.ecma-international.org/6.0/#sec-isregexp + +module.exports = function IsRegExp(argument) { + if (!isObject(argument)) { + return false; + } + if ($match) { + var isRegExp = argument[$match]; + if (typeof isRegExp !== 'undefined') { + return ToBoolean(isRegExp); + } + } + return hasRegExpMatcher(argument); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsWordChar.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsWordChar.js new file mode 100644 index 0000000000000000000000000000000000000000..d8a3f9781f4af9a7a2ca52474e2294e2252f78aa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IsWordChar.js @@ -0,0 +1,37 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var IsArray = require('./IsArray'); +var IsInteger = require('./IsInteger'); + +var every = require('../helpers/every'); +var regexTester = require('safe-regex-test'); + +var isChar = function isChar(c) { + return typeof c === 'string' && c.length === 1; +}; + +var isWordCharacter = regexTester(/^[a-zA-Z0-9_]$/); + +// https://262.ecma-international.org/6.0/#sec-runtime-semantics-iswordchar-abstract-operation + +// note: prior to ES2023, this AO erroneously omitted the latter of its arguments. +module.exports = function IsWordChar(e, InputLength, Input) { + if (!IsInteger(e)) { + throw new $TypeError('Assertion failed: `e` must be an integer'); + } + if (!IsInteger(InputLength)) { + throw new $TypeError('Assertion failed: `InputLength` must be an integer'); + } + if (!IsArray(Input) || !every(Input, isChar)) { + throw new $TypeError('Assertion failed: `Input` must be a List of characters'); + } + if (e === -1 || e === InputLength) { + return false; // step 1 + } + + var c = Input[e]; // step 2 + + return isWordCharacter(c); // steps 3-4 +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IterableToArrayLike.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IterableToArrayLike.js new file mode 100644 index 0000000000000000000000000000000000000000..348b9ebcc56db6ab7c4341b07d1c119690c1b257 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IterableToArrayLike.js @@ -0,0 +1,34 @@ +'use strict'; + +var getIteratorMethod = require('../helpers/getIteratorMethod'); +var AdvanceStringIndex = require('./AdvanceStringIndex'); +var GetIterator = require('./GetIterator'); +var GetMethod = require('./GetMethod'); +var IteratorStep = require('./IteratorStep'); +var IteratorValue = require('./IteratorValue'); +var ToObject = require('./ToObject'); +var ES = { + AdvanceStringIndex: AdvanceStringIndex, + GetMethod: GetMethod +}; + +// https://262.ecma-international.org/7.0/#sec-iterabletoarraylike + +module.exports = function IterableToArrayLike(items) { + var usingIterator = getIteratorMethod(ES, items); + if (typeof usingIterator !== 'undefined') { + var iterator = GetIterator(items, usingIterator); + var values = []; + var next = true; + while (next) { + next = IteratorStep(iterator); + if (next) { + var nextValue = IteratorValue(next); + values[values.length] = nextValue; + } + } + return values; + } + + return ToObject(items); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IteratorClose.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IteratorClose.js new file mode 100644 index 0000000000000000000000000000000000000000..e3e51d981459cc3ae61c9555d12914a3898ed467 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IteratorClose.js @@ -0,0 +1,49 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var Call = require('./Call'); +var CompletionRecord = require('./CompletionRecord'); +var GetMethod = require('./GetMethod'); +var IsCallable = require('./IsCallable'); + +// https://262.ecma-international.org/6.0/#sec-iteratorclose + +module.exports = function IteratorClose(iterator, completion) { + if (!isObject(iterator)) { + throw new $TypeError('Assertion failed: Type(iterator) is not Object'); + } + if (!IsCallable(completion) && !(completion instanceof CompletionRecord)) { + throw new $TypeError('Assertion failed: completion is not a thunk representing a Completion Record, nor a Completion Record instance'); + } + var completionThunk = completion instanceof CompletionRecord ? function () { return completion['?'](); } : completion; + + var iteratorReturn = GetMethod(iterator, 'return'); + + if (typeof iteratorReturn === 'undefined') { + return completionThunk(); + } + + var completionRecord; + try { + var innerResult = Call(iteratorReturn, iterator, []); + } catch (e) { + // if we hit here, then "e" is the innerResult completion that needs re-throwing + + // if the completion is of type "throw", this will throw. + completionThunk(); + completionThunk = null; // ensure it's not called twice. + + // if not, then return the innerResult completion + throw e; + } + completionRecord = completionThunk(); // if innerResult worked, then throw if the completion does + completionThunk = null; // ensure it's not called twice. + + if (!isObject(innerResult)) { + throw new $TypeError('iterator .return must return an object'); + } + + return completionRecord; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IteratorComplete.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IteratorComplete.js new file mode 100644 index 0000000000000000000000000000000000000000..c8a0d67c244bbec3d032bb8a4cc5597b7419d97b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IteratorComplete.js @@ -0,0 +1,16 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var Get = require('./Get'); +var ToBoolean = require('./ToBoolean'); + +// https://262.ecma-international.org/6.0/#sec-iteratorcomplete + +module.exports = function IteratorComplete(iterResult) { + if (!isObject(iterResult)) { + throw new $TypeError('Assertion failed: Type(iterResult) is not Object'); + } + return ToBoolean(Get(iterResult, 'done')); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IteratorNext.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IteratorNext.js new file mode 100644 index 0000000000000000000000000000000000000000..b6bd71c68fca61d152bbf420aa5fdfb2feeab854 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IteratorNext.js @@ -0,0 +1,16 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var Invoke = require('./Invoke'); + +// https://262.ecma-international.org/6.0/#sec-iteratornext + +module.exports = function IteratorNext(iterator, value) { + var result = Invoke(iterator, 'next', arguments.length < 2 ? [] : [value]); + if (!isObject(result)) { + throw new $TypeError('iterator next must return an object'); + } + return result; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IteratorStep.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IteratorStep.js new file mode 100644 index 0000000000000000000000000000000000000000..85bcd95c0410f7efd79ae16b91b0a513d404a64a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IteratorStep.js @@ -0,0 +1,13 @@ +'use strict'; + +var IteratorComplete = require('./IteratorComplete'); +var IteratorNext = require('./IteratorNext'); + +// https://262.ecma-international.org/6.0/#sec-iteratorstep + +module.exports = function IteratorStep(iterator) { + var result = IteratorNext(iterator); + var done = IteratorComplete(result); + return done === true ? false : result; +}; + diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IteratorValue.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IteratorValue.js new file mode 100644 index 0000000000000000000000000000000000000000..016ddfbd4f01381dd13487740d6806003449d4b1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/IteratorValue.js @@ -0,0 +1,16 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var Get = require('./Get'); + +// https://262.ecma-international.org/6.0/#sec-iteratorvalue + +module.exports = function IteratorValue(iterResult) { + if (!isObject(iterResult)) { + throw new $TypeError('Assertion failed: Type(iterResult) is not Object'); + } + return Get(iterResult, 'value'); +}; + diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/MakeDate.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/MakeDate.js new file mode 100644 index 0000000000000000000000000000000000000000..3256ae1092afd21a469f4ca086dc028a73ecaa52 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/MakeDate.js @@ -0,0 +1,14 @@ +'use strict'; + +var $isFinite = require('math-intrinsics/isFinite'); + +var msPerDay = require('../helpers/timeConstants').msPerDay; + +// https://262.ecma-international.org/5.1/#sec-15.9.1.13 + +module.exports = function MakeDate(day, time) { + if (!$isFinite(day) || !$isFinite(time)) { + return NaN; + } + return (day * msPerDay) + time; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/MakeDay.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/MakeDay.js new file mode 100644 index 0000000000000000000000000000000000000000..d03d683855826fe3e3889b737b06a08c34ff4442 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/MakeDay.js @@ -0,0 +1,33 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $DateUTC = GetIntrinsic('%Date.UTC%'); + +var $isFinite = require('math-intrinsics/isFinite'); + +var DateFromTime = require('./DateFromTime'); +var Day = require('./Day'); +var floor = require('./floor'); +var modulo = require('./modulo'); +var MonthFromTime = require('./MonthFromTime'); +var ToInteger = require('./ToInteger'); +var YearFromTime = require('./YearFromTime'); + +// https://262.ecma-international.org/5.1/#sec-15.9.1.12 + +module.exports = function MakeDay(year, month, date) { + if (!$isFinite(year) || !$isFinite(month) || !$isFinite(date)) { + return NaN; + } + var y = ToInteger(year); + var m = ToInteger(month); + var dt = ToInteger(date); + var ym = y + floor(m / 12); + var mn = modulo(m, 12); + var t = $DateUTC(ym, mn, 1); + if (YearFromTime(t) !== ym || MonthFromTime(t) !== mn || DateFromTime(t) !== 1) { + return NaN; + } + return Day(t) + dt - 1; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/MakeTime.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/MakeTime.js new file mode 100644 index 0000000000000000000000000000000000000000..94096d6d4ec8833fa6df121cdef28a8da19c150a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/MakeTime.js @@ -0,0 +1,24 @@ +'use strict'; + +var $isFinite = require('math-intrinsics/isFinite'); + +var timeConstants = require('../helpers/timeConstants'); +var msPerSecond = timeConstants.msPerSecond; +var msPerMinute = timeConstants.msPerMinute; +var msPerHour = timeConstants.msPerHour; + +var ToInteger = require('./ToInteger'); + +// https://262.ecma-international.org/5.1/#sec-15.9.1.11 + +module.exports = function MakeTime(hour, min, sec, ms) { + if (!$isFinite(hour) || !$isFinite(min) || !$isFinite(sec) || !$isFinite(ms)) { + return NaN; + } + var h = ToInteger(hour); + var m = ToInteger(min); + var s = ToInteger(sec); + var milli = ToInteger(ms); + var t = (h * msPerHour) + (m * msPerMinute) + (s * msPerSecond) + milli; + return t; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/MinFromTime.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/MinFromTime.js new file mode 100644 index 0000000000000000000000000000000000000000..a0c631d4cc56cb21e15712def6008d5623edd0f9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/MinFromTime.js @@ -0,0 +1,14 @@ +'use strict'; + +var floor = require('./floor'); +var modulo = require('./modulo'); + +var timeConstants = require('../helpers/timeConstants'); +var msPerMinute = timeConstants.msPerMinute; +var MinutesPerHour = timeConstants.MinutesPerHour; + +// https://262.ecma-international.org/5.1/#sec-15.9.1.10 + +module.exports = function MinFromTime(t) { + return modulo(floor(t / msPerMinute), MinutesPerHour); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/MonthFromTime.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/MonthFromTime.js new file mode 100644 index 0000000000000000000000000000000000000000..e551ee2be6da5cc49c7da94be78095c0803c53d9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/MonthFromTime.js @@ -0,0 +1,51 @@ +'use strict'; + +var $RangeError = require('es-errors/range'); + +var DayWithinYear = require('./DayWithinYear'); +var InLeapYear = require('./InLeapYear'); + +// https://262.ecma-international.org/5.1/#sec-15.9.1.4 + +module.exports = function MonthFromTime(t) { + var day = DayWithinYear(t); + if (0 <= day && day < 31) { + return 0; + } + var leap = InLeapYear(t); + if (31 <= day && day < (59 + leap)) { + return 1; + } + if ((59 + leap) <= day && day < (90 + leap)) { + return 2; + } + if ((90 + leap) <= day && day < (120 + leap)) { + return 3; + } + if ((120 + leap) <= day && day < (151 + leap)) { + return 4; + } + if ((151 + leap) <= day && day < (181 + leap)) { + return 5; + } + if ((181 + leap) <= day && day < (212 + leap)) { + return 6; + } + if ((212 + leap) <= day && day < (243 + leap)) { + return 7; + } + if ((243 + leap) <= day && day < (273 + leap)) { + return 8; + } + if ((273 + leap) <= day && day < (304 + leap)) { + return 9; + } + if ((304 + leap) <= day && day < (334 + leap)) { + return 10; + } + if ((334 + leap) <= day && day < (365 + leap)) { + return 11; + } + + throw new $RangeError('Assertion failed: `day` is out of range'); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/NewPromiseCapability.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/NewPromiseCapability.js new file mode 100644 index 0000000000000000000000000000000000000000..893266fe9f8da7b032d6fc835750a07c30086179 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/NewPromiseCapability.js @@ -0,0 +1,34 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var IsCallable = require('./IsCallable'); +var IsConstructor = require('./IsConstructor'); + +// https://262.ecma-international.org/6.0/#sec-newpromisecapability + +module.exports = function NewPromiseCapability(C) { + if (!IsConstructor(C)) { + throw new $TypeError('C must be a constructor'); // step 1 + } + + var resolvingFunctions = { '[[Resolve]]': void undefined, '[[Reject]]': void undefined }; // step 3 + + var promise = new C(function (resolve, reject) { // steps 4-5 + if (typeof resolvingFunctions['[[Resolve]]'] !== 'undefined' || typeof resolvingFunctions['[[Reject]]'] !== 'undefined') { + throw new $TypeError('executor has already been called'); // step 4.a, 4.b + } + resolvingFunctions['[[Resolve]]'] = resolve; // step 4.c + resolvingFunctions['[[Reject]]'] = reject; // step 4.d + }); // step 4-6 + + if (!IsCallable(resolvingFunctions['[[Resolve]]']) || !IsCallable(resolvingFunctions['[[Reject]]'])) { + throw new $TypeError('executor must provide valid resolve and reject functions'); // steps 7-8 + } + + return { + '[[Promise]]': promise, + '[[Resolve]]': resolvingFunctions['[[Resolve]]'], + '[[Reject]]': resolvingFunctions['[[Reject]]'] + }; // step 9 +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/NormalCompletion.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/NormalCompletion.js new file mode 100644 index 0000000000000000000000000000000000000000..1e429dd65cfaded0bd09155819605198a45c628d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/NormalCompletion.js @@ -0,0 +1,9 @@ +'use strict'; + +var CompletionRecord = require('./CompletionRecord'); + +// https://262.ecma-international.org/6.0/#sec-normalcompletion + +module.exports = function NormalCompletion(value) { + return new CompletionRecord('normal', value); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ObjectCreate.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ObjectCreate.js new file mode 100644 index 0000000000000000000000000000000000000000..c2ef47578051e1b9f051c3daef6a9e0e88055032 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ObjectCreate.js @@ -0,0 +1,50 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $ObjectCreate = GetIntrinsic('%Object.create%', true); +var $TypeError = require('es-errors/type'); +var $SyntaxError = require('es-errors/syntax'); +var isObject = require('es-object-atoms/isObject'); + +var IsArray = require('./IsArray'); + +var forEach = require('../helpers/forEach'); + +var SLOT = require('internal-slot'); + +var hasProto = require('has-proto')(); + +// https://262.ecma-international.org/6.0/#sec-objectcreate + +module.exports = function ObjectCreate(proto, internalSlotsList) { + if (proto !== null && !isObject(proto)) { + throw new $TypeError('Assertion failed: `proto` must be null or an object'); + } + var slots = arguments.length < 2 ? [] : internalSlotsList; // step 1 + if (arguments.length >= 2 && !IsArray(slots)) { + throw new $TypeError('Assertion failed: `internalSlotsList` must be an Array'); + } + + var O; + if (hasProto) { + O = { __proto__: proto }; + } else if ($ObjectCreate) { + O = $ObjectCreate(proto); + } else { + if (proto === null) { + throw new $SyntaxError('native Object.create support is required to create null objects'); + } + var T = function T() {}; + T.prototype = proto; + O = new T(); + } + + if (slots.length > 0) { + forEach(slots, function (slot) { + SLOT.set(O, slot, void undefined); + }); + } + + return O; // step 6 +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ObjectDefineProperties.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ObjectDefineProperties.js new file mode 100644 index 0000000000000000000000000000000000000000..0d41322bcc146b95dea2f81dbb533ed69495414a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ObjectDefineProperties.js @@ -0,0 +1,37 @@ +'use strict'; + +var DefinePropertyOrThrow = require('./DefinePropertyOrThrow'); +var Get = require('./Get'); +var OrdinaryGetOwnProperty = require('./OrdinaryGetOwnProperty'); +var ToObject = require('./ToObject'); +var ToPropertyDescriptor = require('./ToPropertyDescriptor'); + +var forEach = require('../helpers/forEach'); +var OwnPropertyKeys = require('own-keys'); + +// https://262.ecma-international.org/6.0/#sec-objectdefineproperties + +/** @type { = {}>(O: T, Properties: object) => T} */ +module.exports = function ObjectDefineProperties(O, Properties) { + var props = ToObject(Properties); // step 1 + var keys = OwnPropertyKeys(props); // step 2 + /** @type {[string | symbol, import('../types').Descriptor][]} */ + var descriptors = []; // step 3 + + forEach(keys, function (nextKey) { // step 4 + var propDesc = OrdinaryGetOwnProperty(props, nextKey); // ToPropertyDescriptor(getOwnPropertyDescriptor(props, nextKey)); // step 4.a + if (typeof propDesc !== 'undefined' && propDesc['[[Enumerable]]']) { // step 4.b + var descObj = Get(props, nextKey); // step 4.b.i + var desc = ToPropertyDescriptor(descObj); // step 4.b.ii + descriptors[descriptors.length] = [nextKey, desc]; // step 4.b.iii + } + }); + + forEach(descriptors, function (pair) { // step 5 + var P = pair[0]; // step 5.a + var desc = pair[1]; // step 5.b + DefinePropertyOrThrow(O, P, desc); // step 5.c + }); + + return O; // step 6 +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/OrdinaryCreateFromConstructor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/OrdinaryCreateFromConstructor.js new file mode 100644 index 0000000000000000000000000000000000000000..f84b410439c2e3534ec9b5fa619766962cd4264a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/OrdinaryCreateFromConstructor.js @@ -0,0 +1,20 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); +var $TypeError = require('es-errors/type'); + +var GetPrototypeFromConstructor = require('./GetPrototypeFromConstructor'); +var IsArray = require('./IsArray'); +var ObjectCreate = require('./ObjectCreate'); + +// https://262.ecma-international.org/6.0/#sec-ordinarycreatefromconstructor + +module.exports = function OrdinaryCreateFromConstructor(constructor, intrinsicDefaultProto) { + GetIntrinsic(intrinsicDefaultProto); // throws if not a valid intrinsic + var proto = GetPrototypeFromConstructor(constructor, intrinsicDefaultProto); + var slots = arguments.length < 3 ? [] : arguments[2]; + if (!IsArray(slots)) { + throw new $TypeError('Assertion failed: if provided, `internalSlotsList` must be a List'); + } + return ObjectCreate(proto, slots); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/OrdinaryDefineOwnProperty.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/OrdinaryDefineOwnProperty.js new file mode 100644 index 0000000000000000000000000000000000000000..1a61488c6311f778620cdccb377e0b377040b055 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/OrdinaryDefineOwnProperty.js @@ -0,0 +1,54 @@ +'use strict'; + +var $gOPD = require('gopd'); +var $SyntaxError = require('es-errors/syntax'); +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var isPropertyDescriptor = require('../helpers/records/property-descriptor'); + +var IsAccessorDescriptor = require('./IsAccessorDescriptor'); +var IsExtensible = require('./IsExtensible'); +var isPropertyKey = require('../helpers/isPropertyKey'); +var ToPropertyDescriptor = require('./ToPropertyDescriptor'); +var SameValue = require('./SameValue'); +var ValidateAndApplyPropertyDescriptor = require('./ValidateAndApplyPropertyDescriptor'); + +// https://262.ecma-international.org/6.0/#sec-ordinarydefineownproperty + +module.exports = function OrdinaryDefineOwnProperty(O, P, Desc) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: O must be an Object'); + } + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: P must be a Property Key'); + } + if (!isPropertyDescriptor(Desc)) { + throw new $TypeError('Assertion failed: Desc must be a Property Descriptor'); + } + if (!$gOPD) { + // ES3/IE 8 fallback + if (IsAccessorDescriptor(Desc)) { + throw new $SyntaxError('This environment does not support accessor property descriptors.'); + } + var creatingNormalDataProperty = !(P in O) + && Desc['[[Writable]]'] + && Desc['[[Enumerable]]'] + && Desc['[[Configurable]]'] + && '[[Value]]' in Desc; + var settingExistingDataProperty = (P in O) + && (!('[[Configurable]]' in Desc) || Desc['[[Configurable]]']) + && (!('[[Enumerable]]' in Desc) || Desc['[[Enumerable]]']) + && (!('[[Writable]]' in Desc) || Desc['[[Writable]]']) + && '[[Value]]' in Desc; + if (creatingNormalDataProperty || settingExistingDataProperty) { + O[P] = Desc['[[Value]]']; // eslint-disable-line no-param-reassign + return SameValue(O[P], Desc['[[Value]]']); + } + throw new $SyntaxError('This environment does not support defining non-writable, non-enumerable, or non-configurable properties'); + } + var desc = $gOPD(O, P); + var current = desc && ToPropertyDescriptor(desc); + var extensible = IsExtensible(O); + return ValidateAndApplyPropertyDescriptor(O, P, extensible, Desc, current); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/OrdinaryGetOwnProperty.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/OrdinaryGetOwnProperty.js new file mode 100644 index 0000000000000000000000000000000000000000..fdf6cc0cad72a7d2af37ee6eb9db36cffde6b822 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/OrdinaryGetOwnProperty.js @@ -0,0 +1,40 @@ +'use strict'; + +var $gOPD = require('gopd'); +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); +var hasOwn = require('hasown'); +var callBound = require('call-bound'); + +var $isEnumerable = callBound('Object.prototype.propertyIsEnumerable'); + +var IsArray = require('./IsArray'); +var isPropertyKey = require('../helpers/isPropertyKey'); +var IsRegExp = require('./IsRegExp'); +var ToPropertyDescriptor = require('./ToPropertyDescriptor'); + +// https://262.ecma-international.org/6.0/#sec-ordinarygetownproperty + +module.exports = function OrdinaryGetOwnProperty(O, P) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: O must be an Object'); + } + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: P must be a Property Key'); + } + if (!hasOwn(O, P)) { + return void 0; + } + if (!$gOPD) { + // ES3 / IE 8 fallback + var arrayLength = IsArray(O) && P === 'length'; + var regexLastIndex = IsRegExp(O) && P === 'lastIndex'; + return { + '[[Configurable]]': !(arrayLength || regexLastIndex), + '[[Enumerable]]': $isEnumerable(O, P), + '[[Value]]': O[P], + '[[Writable]]': true + }; + } + return ToPropertyDescriptor($gOPD(O, P)); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/OrdinaryGetPrototypeOf.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/OrdinaryGetPrototypeOf.js new file mode 100644 index 0000000000000000000000000000000000000000..7ef8bee34617c4ecaa2bd4b55cf1eb6a6665fe50 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/OrdinaryGetPrototypeOf.js @@ -0,0 +1,18 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var $getProto = require('get-proto'); + +// https://262.ecma-international.org/7.0/#sec-ordinarygetprototypeof + +module.exports = function OrdinaryGetPrototypeOf(O) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: O must be an Object'); + } + if (!$getProto) { + throw new $TypeError('This environment does not support fetching prototypes.'); + } + return $getProto(O); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/OrdinaryHasInstance.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/OrdinaryHasInstance.js new file mode 100644 index 0000000000000000000000000000000000000000..a0a83e6733a49e898d0f9db5df20a54028ad69e3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/OrdinaryHasInstance.js @@ -0,0 +1,23 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var Get = require('./Get'); +var IsCallable = require('./IsCallable'); + +// https://262.ecma-international.org/6.0/#sec-ordinaryhasinstance + +module.exports = function OrdinaryHasInstance(C, O) { + if (!IsCallable(C)) { + return false; + } + if (!isObject(O)) { + return false; + } + var P = Get(C, 'prototype'); + if (!isObject(P)) { + throw new $TypeError('OrdinaryHasInstance called on an object with an invalid prototype property.'); + } + return O instanceof C; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/OrdinaryHasProperty.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/OrdinaryHasProperty.js new file mode 100644 index 0000000000000000000000000000000000000000..c6c5c11961374a2c3c4beb751aca52a9973093d6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/OrdinaryHasProperty.js @@ -0,0 +1,18 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var isPropertyKey = require('../helpers/isPropertyKey'); + +// https://262.ecma-international.org/6.0/#sec-ordinaryhasproperty + +module.exports = function OrdinaryHasProperty(O, P) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: Type(O) is not Object'); + } + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: P must be a Property Key'); + } + return P in O; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/OrdinarySetPrototypeOf.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/OrdinarySetPrototypeOf.js new file mode 100644 index 0000000000000000000000000000000000000000..b493a442ddd22b125fde2ed40eeebddf2d080a2d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/OrdinarySetPrototypeOf.js @@ -0,0 +1,50 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var $setProto = require('set-proto'); +var isObject = require('es-object-atoms/isObject'); + +var OrdinaryGetPrototypeOf = require('./OrdinaryGetPrototypeOf'); + +// https://262.ecma-international.org/7.0/#sec-ordinarysetprototypeof + +module.exports = function OrdinarySetPrototypeOf(O, V) { + if (V !== null && !isObject(V)) { + throw new $TypeError('Assertion failed: V must be Object or Null'); + } + /* + var extensible = IsExtensible(O); + var current = OrdinaryGetPrototypeOf(O); + if (SameValue(V, current)) { + return true; + } + if (!extensible) { + return false; + } + */ + try { + $setProto(O, V); + } catch (e) { + return false; + } + return OrdinaryGetPrototypeOf(O) === V; + /* + var p = V; + var done = false; + while (!done) { + if (p === null) { + done = true; + } else if (SameValue(p, O)) { + return false; + } else { + if (wat) { + done = true; + } else { + p = p.[[Prototype]]; + } + } + } + O.[[Prototype]] = V; + return true; + */ +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/QuoteJSONString.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/QuoteJSONString.js new file mode 100644 index 0000000000000000000000000000000000000000..616304b82562a0bf5392caf1e0b5bde489dcd7ee --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/QuoteJSONString.js @@ -0,0 +1,48 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var callBound = require('call-bound'); +var forEach = require('../helpers/forEach'); + +var $charCodeAt = callBound('String.prototype.charCodeAt'); +var $numberToString = callBound('Number.prototype.toString'); +var $toLowerCase = callBound('String.prototype.toLowerCase'); +var $strSlice = callBound('String.prototype.slice'); +var $strSplit = callBound('String.prototype.split'); + +// https://262.ecma-international.org/6.0/#sec-quotejsonstring + +var escapes = { + '\u0008': 'b', + '\u000C': 'f', + '\u000A': 'n', + '\u000D': 'r', + '\u0009': 't' +}; + +module.exports = function QuoteJSONString(value) { + if (typeof value !== 'string') { + throw new $TypeError('Assertion failed: `value` must be a String'); + } + var product = '"'; + if (value) { + forEach($strSplit(value, ''), function (C) { + if (C === '"' || C === '\\') { + product += '\u005C' + C; + } else if (C === '\u0008' || C === '\u000C' || C === '\u000A' || C === '\u000D' || C === '\u0009') { + var abbrev = escapes[C]; + product += '\u005C' + abbrev; + } else { + var cCharCode = $charCodeAt(C, 0); + if (cCharCode < 0x20) { + product += '\u005Cu' + $toLowerCase($strSlice('0000' + $numberToString(cCharCode, 16), -4)); + } else { + product += C; + } + } + }); + } + product += '"'; + return product; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/RegExpCreate.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/RegExpCreate.js new file mode 100644 index 0000000000000000000000000000000000000000..68e31605ed1764b9e1addddc5b910e9c9d73fba2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/RegExpCreate.js @@ -0,0 +1,21 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $RegExp = GetIntrinsic('%RegExp%'); + +// var RegExpAlloc = require('./RegExpAlloc'); +// var RegExpInitialize = require('./RegExpInitialize'); +var ToString = require('./ToString'); + +// https://262.ecma-international.org/6.0/#sec-regexpcreate + +module.exports = function RegExpCreate(P, F) { + // var obj = RegExpAlloc($RegExp); + // return RegExpInitialize(obj, P, F); + + // covers spec mechanics; bypass regex brand checking + var pattern = typeof P === 'undefined' ? '' : ToString(P); + var flags = typeof F === 'undefined' ? '' : ToString(F); + return new $RegExp(pattern, flags); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/RegExpExec.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/RegExpExec.js new file mode 100644 index 0000000000000000000000000000000000000000..15762b8343aa380c2c90257eef552a87c56745ae --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/RegExpExec.js @@ -0,0 +1,29 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); +var regexExec = require('call-bound')('RegExp.prototype.exec'); + +var Call = require('./Call'); +var Get = require('./Get'); +var IsCallable = require('./IsCallable'); + +// https://262.ecma-international.org/6.0/#sec-regexpexec + +module.exports = function RegExpExec(R, S) { + if (!isObject(R)) { + throw new $TypeError('Assertion failed: `R` must be an Object'); + } + if (typeof S !== 'string') { + throw new $TypeError('Assertion failed: `S` must be a String'); + } + var exec = Get(R, 'exec'); + if (IsCallable(exec)) { + var result = Call(exec, R, [S]); + if (result === null || isObject(result)) { + return result; + } + throw new $TypeError('"exec" method must return `null` or an Object'); + } + return regexExec(R, S); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/RequireObjectCoercible.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/RequireObjectCoercible.js new file mode 100644 index 0000000000000000000000000000000000000000..b816d1f34b01a80352e783672836a17c49cc06f0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/RequireObjectCoercible.js @@ -0,0 +1,3 @@ +'use strict'; + +module.exports = require('es-object-atoms/RequireObjectCoercible'); diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SameValue.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SameValue.js new file mode 100644 index 0000000000000000000000000000000000000000..d07bbb8a8f3fec5ad22ffdfb617245331fcff412 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SameValue.js @@ -0,0 +1,13 @@ +'use strict'; + +var $isNaN = require('math-intrinsics/isNaN'); + +// http://262.ecma-international.org/5.1/#sec-9.12 + +module.exports = function SameValue(x, y) { + if (x === y) { // 0 === -0, but they are not identical. + if (x === 0) { return 1 / x === 1 / y; } + return true; + } + return $isNaN(x) && $isNaN(y); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SameValueNonNumber.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SameValueNonNumber.js new file mode 100644 index 0000000000000000000000000000000000000000..2d3b3de5c7a1ec0126d4e2b65e36aaa92b994309 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SameValueNonNumber.js @@ -0,0 +1,14 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); + +var SameValue = require('./SameValue'); + +// https://262.ecma-international.org/7.0/#sec-samevaluenonnumber + +module.exports = function SameValueNonNumber(x, y) { + if (typeof x === 'number' || typeof x !== typeof y) { + throw new $TypeError('SameValueNonNumber requires two non-number values of the same type.'); + } + return SameValue(x, y); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SameValueZero.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SameValueZero.js new file mode 100644 index 0000000000000000000000000000000000000000..8880e915941eeae2d890f2bdeb1bd057516e3d50 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SameValueZero.js @@ -0,0 +1,9 @@ +'use strict'; + +var $isNaN = require('math-intrinsics/isNaN'); + +// https://262.ecma-international.org/6.0/#sec-samevaluezero + +module.exports = function SameValueZero(x, y) { + return (x === y) || ($isNaN(x) && $isNaN(y)); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SecFromTime.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SecFromTime.js new file mode 100644 index 0000000000000000000000000000000000000000..fc2e44560240f134cf345e63ab69d5f8a2d8cec1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SecFromTime.js @@ -0,0 +1,14 @@ +'use strict'; + +var floor = require('./floor'); +var modulo = require('./modulo'); + +var timeConstants = require('../helpers/timeConstants'); +var msPerSecond = timeConstants.msPerSecond; +var SecondsPerMinute = timeConstants.SecondsPerMinute; + +// https://262.ecma-international.org/5.1/#sec-15.9.1.10 + +module.exports = function SecFromTime(t) { + return modulo(floor(t / msPerSecond), SecondsPerMinute); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/Set.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/Set.js new file mode 100644 index 0000000000000000000000000000000000000000..f814076a8fb813648eb16093fe86a46182c0fccf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/Set.js @@ -0,0 +1,45 @@ +'use strict'; + +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var isPropertyKey = require('../helpers/isPropertyKey'); +var SameValue = require('./SameValue'); + +// IE 9 does not throw in strict mode when writability/configurability/extensibility is violated +var noThrowOnStrictViolation = (function () { + try { + delete [].length; + return true; + } catch (e) { + return false; + } +}()); + +// https://262.ecma-international.org/6.0/#sec-set-o-p-v-throw + +module.exports = function Set(O, P, V, Throw) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: `O` must be an Object'); + } + if (!isPropertyKey(P)) { + throw new $TypeError('Assertion failed: `P` must be a Property Key'); + } + if (typeof Throw !== 'boolean') { + throw new $TypeError('Assertion failed: `Throw` must be a Boolean'); + } + if (Throw) { + O[P] = V; // eslint-disable-line no-param-reassign + if (noThrowOnStrictViolation && !SameValue(O[P], V)) { + throw new $TypeError('Attempted to assign to readonly property.'); + } + return true; + } + try { + O[P] = V; // eslint-disable-line no-param-reassign + return noThrowOnStrictViolation ? SameValue(O[P], V) : true; + } catch (e) { + return false; + } + +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SetFunctionName.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SetFunctionName.js new file mode 100644 index 0000000000000000000000000000000000000000..9e8511fd46bc115d0459cc66f44bb6560ba2bc3a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SetFunctionName.js @@ -0,0 +1,40 @@ +'use strict'; + +var hasOwn = require('hasown'); + +var $TypeError = require('es-errors/type'); + +var getSymbolDescription = require('get-symbol-description'); + +var DefinePropertyOrThrow = require('./DefinePropertyOrThrow'); +var IsExtensible = require('./IsExtensible'); + +// https://262.ecma-international.org/6.0/#sec-setfunctionname + +module.exports = function SetFunctionName(F, name) { + if (typeof F !== 'function') { + throw new $TypeError('Assertion failed: `F` must be a function'); + } + if (!IsExtensible(F) || hasOwn(F, 'name')) { + throw new $TypeError('Assertion failed: `F` must be extensible, and must not have a `name` own property'); + } + if (typeof name !== 'symbol' && typeof name !== 'string') { + throw new $TypeError('Assertion failed: `name` must be a Symbol or a String'); + } + if (typeof name === 'symbol') { + var description = getSymbolDescription(name); + // eslint-disable-next-line no-param-reassign + name = typeof description === 'undefined' ? '' : '[' + description + ']'; + } + if (arguments.length > 2) { + var prefix = arguments[2]; + // eslint-disable-next-line no-param-reassign + name = prefix + ' ' + name; + } + return DefinePropertyOrThrow(F, 'name', { + '[[Value]]': name, + '[[Writable]]': false, + '[[Enumerable]]': false, + '[[Configurable]]': true + }); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SetIntegrityLevel.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SetIntegrityLevel.js new file mode 100644 index 0000000000000000000000000000000000000000..ad92fb99b004f2b05e23fa0b2ef45dfc3775025e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SetIntegrityLevel.js @@ -0,0 +1,57 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $SyntaxError = require('es-errors/syntax'); +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); +var $gOPD = require('gopd'); +var $preventExtensions = GetIntrinsic('%Object.preventExtensions%', true); +var $gOPN = GetIntrinsic('%Object.getOwnPropertyNames%', true); + +var forEach = require('../helpers/forEach'); + +var DefinePropertyOrThrow = require('./DefinePropertyOrThrow'); +var IsAccessorDescriptor = require('./IsAccessorDescriptor'); +var ToPropertyDescriptor = require('./ToPropertyDescriptor'); + +// https://262.ecma-international.org/6.0/#sec-setintegritylevel + +module.exports = function SetIntegrityLevel(O, level) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: Type(O) is not Object'); + } + if (level !== 'sealed' && level !== 'frozen') { + throw new $TypeError('Assertion failed: `level` must be `"sealed"` or `"frozen"`'); + } + if (!$preventExtensions) { + throw new $SyntaxError('SetIntegrityLevel requires native `Object.preventExtensions` support'); + } + var status = $preventExtensions(O); + if (!status) { + return false; + } + if (!$gOPN) { + throw new $SyntaxError('SetIntegrityLevel requires native `Object.getOwnPropertyNames` support'); + } + var theKeys = $gOPN(O); + if (level === 'sealed') { + forEach(theKeys, function (k) { + DefinePropertyOrThrow(O, k, { configurable: false }); + }); + } else if (level === 'frozen') { + forEach(theKeys, function (k) { + var currentDesc = $gOPD(O, k); + if (typeof currentDesc !== 'undefined') { + var desc; + if (IsAccessorDescriptor(ToPropertyDescriptor(currentDesc))) { + desc = { configurable: false }; + } else { + desc = { configurable: false, writable: false }; + } + DefinePropertyOrThrow(O, k, desc); + } + }); + } + return true; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SetValueInBuffer.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SetValueInBuffer.js new file mode 100644 index 0000000000000000000000000000000000000000..0efd30163be06cc4a2929ccbd9b104b30b0b14ef --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SetValueInBuffer.js @@ -0,0 +1,110 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $TypeError = require('es-errors/type'); +var $Uint8Array = GetIntrinsic('%Uint8Array%', true); + +var isInteger = require('math-intrinsics/isInteger'); + +var IsDetachedBuffer = require('./IsDetachedBuffer'); +var ToInt16 = require('./ToInt16'); +var ToInt32 = require('./ToInt32'); +var ToInt8 = require('./ToInt8'); +var ToUint16 = require('./ToUint16'); +var ToUint32 = require('./ToUint32'); +var ToUint8 = require('./ToUint8'); +var ToUint8Clamp = require('./ToUint8Clamp'); + +var isArrayBuffer = require('is-array-buffer'); +var hasOwn = require('hasown'); + +var tableTAO = require('./tables/typed-array-objects'); + +var TypeToAO = { + __proto__: null, + $Int8: ToInt8, + $Uint8: ToUint8, + $Uint8C: ToUint8Clamp, + $Int16: ToInt16, + $Uint16: ToUint16, + $Int32: ToInt32, + $Uint32: ToUint32 +}; + +var defaultEndianness = require('../helpers/defaultEndianness'); +var forEach = require('../helpers/forEach'); +var integerToNBytes = require('../helpers/integerToNBytes'); +var valueToFloat32Bytes = require('../helpers/valueToFloat32Bytes'); +var valueToFloat64Bytes = require('../helpers/valueToFloat64Bytes'); + +// https://262.ecma-international.org/6.0/#sec-setvalueinbuffer + +module.exports = function SetValueInBuffer(arrayBuffer, byteIndex, type, value) { + if (!isArrayBuffer(arrayBuffer)) { + throw new $TypeError('Assertion failed: `arrayBuffer` must be an ArrayBuffer'); + } + + if (!isInteger(byteIndex)) { + throw new $TypeError('Assertion failed: `byteIndex` must be an integer'); + } + + if (typeof type !== 'string' || !hasOwn(tableTAO.size, '$' + type)) { + throw new $TypeError('Assertion failed: `type` must be one of ' + tableTAO.choices); + } + + if (typeof value !== 'number') { + throw new $TypeError('Assertion failed: `value` must be a number'); + } + + if (arguments.length > 4 && typeof arguments[4] !== 'boolean') { + throw new $TypeError('Assertion failed: `isLittleEndian` must be a boolean, if present'); + } + + if (IsDetachedBuffer(arrayBuffer)) { + throw new $TypeError('Assertion failed: ArrayBuffer is detached'); // step 1 + } + + // 2. Assert: There are sufficient bytes in arrayBuffer starting at byteIndex to represent a value of type. + + if (byteIndex < 0) { + throw new $TypeError('Assertion failed: `byteIndex` must be non-negative'); // step 3 + } + + // 4. Assert: Type(value) is Number. + + // 5. Let block be arrayBuffer’s [[ArrayBufferData]] internal slot. + + // 6. Assert: block is not undefined. + + var elementSize = tableTAO.size['$' + type]; // step 7 + if (!elementSize) { + throw new $TypeError('Assertion failed: `type` must be one of ' + tableTAO.choices); + } + + // 8. If isLittleEndian is not present, set isLittleEndian to either true or false. The choice is implementation dependent and should be the alternative that is most efficient for the implementation. An implementation must use the same value each time this step is executed and the same value must be used for the corresponding step in the GetValueFromBuffer abstract operation. + var isLittleEndian = arguments.length > 4 ? arguments[4] : defaultEndianness === 'little'; // step 8 + + var rawBytes; + if (type === 'Float32') { // step 1 + rawBytes = valueToFloat32Bytes(value, isLittleEndian); + } else if (type === 'Float64') { // step 2 + rawBytes = valueToFloat64Bytes(value, isLittleEndian); + } else { + var n = elementSize; // step 3.a + + var convOp = TypeToAO['$' + type]; // step 3.b + + var intValue = convOp(value); // step 3.c + + rawBytes = integerToNBytes(intValue, n, isLittleEndian); // step 3.d, 3.e, 4 + } + + // 12. Store the individual bytes of rawBytes into block, in order, starting at block[byteIndex]. + var arr = new $Uint8Array(arrayBuffer, byteIndex, elementSize); + forEach(rawBytes, function (rawByte, i) { + arr[i] = rawByte; + }); + + // 13. Return NormalCompletion(undefined). +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SpeciesConstructor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SpeciesConstructor.js new file mode 100644 index 0000000000000000000000000000000000000000..23e32b443ef3655f56639920d5cf58474500bf67 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SpeciesConstructor.js @@ -0,0 +1,32 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var $species = GetIntrinsic('%Symbol.species%', true); +var $TypeError = require('es-errors/type'); +var isObject = require('es-object-atoms/isObject'); + +var IsConstructor = require('./IsConstructor'); + +// https://262.ecma-international.org/6.0/#sec-speciesconstructor + +module.exports = function SpeciesConstructor(O, defaultConstructor) { + if (!isObject(O)) { + throw new $TypeError('Assertion failed: Type(O) is not Object'); + } + var C = O.constructor; + if (typeof C === 'undefined') { + return defaultConstructor; + } + if (!isObject(C)) { + throw new $TypeError('O.constructor is not an Object'); + } + var S = $species ? C[$species] : void 0; + if (S == null) { + return defaultConstructor; + } + if (IsConstructor(S)) { + return S; + } + throw new $TypeError('no constructor found'); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SplitMatch.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SplitMatch.js new file mode 100644 index 0000000000000000000000000000000000000000..c04fa7f63c6884e6d40b21689784dae891ceb655 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SplitMatch.js @@ -0,0 +1,35 @@ +'use strict'; + +var callBound = require('call-bound'); + +var $TypeError = require('es-errors/type'); +var isInteger = require('math-intrinsics/isInteger'); + +var $charAt = callBound('String.prototype.charAt'); + +// https://262.ecma-international.org/6.0/#sec-splitmatch + +module.exports = function SplitMatch(S, q, R) { + if (typeof S !== 'string') { + throw new $TypeError('Assertion failed: `S` must be a String'); + } + if (!isInteger(q)) { + throw new $TypeError('Assertion failed: `q` must be an integer'); + } + if (typeof R !== 'string') { + throw new $TypeError('Assertion failed: `R` must be a String'); + } + var r = R.length; + var s = S.length; + if (q + r > s) { + return false; + } + + for (var i = 0; i < r; i += 1) { + if ($charAt(S, q + i) !== $charAt(R, i)) { + return false; + } + } + + return q + r; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/StrictEqualityComparison.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/StrictEqualityComparison.js new file mode 100644 index 0000000000000000000000000000000000000000..d056c44e79a546022718908720ab19cd27e7415e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/StrictEqualityComparison.js @@ -0,0 +1,15 @@ +'use strict'; + +var Type = require('./Type'); + +// https://262.ecma-international.org/5.1/#sec-11.9.6 + +module.exports = function StrictEqualityComparison(x, y) { + if (Type(x) !== Type(y)) { + return false; + } + if (typeof x === 'undefined' || x === null) { + return true; + } + return x === y; // shortcut for steps 4-7 +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/abs.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/abs.js new file mode 100644 index 0000000000000000000000000000000000000000..342aa85c66060f7b1cf3a8773cea18b487f3f0a4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/abs.js @@ -0,0 +1,9 @@ +'use strict'; + +var $abs = require('math-intrinsics/abs'); + +// https://262.ecma-international.org/5.1/#sec-5.2 + +module.exports = function abs(x) { + return $abs(x); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/floor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/floor.js new file mode 100644 index 0000000000000000000000000000000000000000..cc53b951167e8f73498de0a1f0e970c52c598f80 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/floor.js @@ -0,0 +1,11 @@ +'use strict'; + +// var modulo = require('./modulo'); +var $floor = require('math-intrinsics/floor'); + +// http://262.ecma-international.org/5.1/#sec-5.2 + +module.exports = function floor(x) { + // return x - modulo(x, 1); + return $floor(x); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/max.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/max.js new file mode 100644 index 0000000000000000000000000000000000000000..f83b038a221fed3a500c72b41f5fdc31e1100827 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/max.js @@ -0,0 +1,5 @@ +'use strict'; + +// https://262.ecma-international.org/6.0/#sec-algorithm-conventions + +module.exports = require('math-intrinsics/max'); diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/min.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/min.js new file mode 100644 index 0000000000000000000000000000000000000000..3a8f50539f0a6519251299edf4169f98a6db0bd9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/min.js @@ -0,0 +1,5 @@ +'use strict'; + +// https://262.ecma-international.org/6.0/#sec-algorithm-conventions + +module.exports = require('math-intrinsics/min'); diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/modulo.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/modulo.js new file mode 100644 index 0000000000000000000000000000000000000000..b94bb52bb3c62e45629a4b1e8f0ebba219d5e41e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/modulo.js @@ -0,0 +1,9 @@ +'use strict'; + +var mod = require('../helpers/mod'); + +// https://262.ecma-international.org/5.1/#sec-5.2 + +module.exports = function modulo(x, y) { + return mod(x, y); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/msFromTime.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/msFromTime.js new file mode 100644 index 0000000000000000000000000000000000000000..a6bae767aed31c8a467b8ea1fb2128e64860a972 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/msFromTime.js @@ -0,0 +1,11 @@ +'use strict'; + +var modulo = require('./modulo'); + +var msPerSecond = require('../helpers/timeConstants').msPerSecond; + +// https://262.ecma-international.org/5.1/#sec-15.9.1.10 + +module.exports = function msFromTime(t) { + return modulo(t, msPerSecond); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2015.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2015.js new file mode 100644 index 0000000000000000000000000000000000000000..9edb26779c4985741f2f51db7bdd584edb9c5997 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2015.js @@ -0,0 +1,744 @@ +'use strict'; + +module.exports = { + IsPropertyDescriptor: 'https://262.ecma-international.org/6.0/#sec-property-descriptor-specification-type', // not actually an abstract op + + abs: { + url: 'https://262.ecma-international.org/6.0/#sec-algorithm-conventions' + }, + 'Abstract Equality Comparison': { + url: 'https://262.ecma-international.org/6.0/#sec-abstract-equality-comparison' + }, + 'Abstract Relational Comparison': { + url: 'https://262.ecma-international.org/6.0/#sec-abstract-relational-comparison' + }, + AddRestrictedFunctionProperties: { + url: 'https://262.ecma-international.org/6.0/#sec-addrestrictedfunctionproperties' + }, + AdvanceStringIndex: { + url: 'https://262.ecma-international.org/6.0/#sec-advancestringindex' + }, + AllocateArrayBuffer: { + url: 'https://262.ecma-international.org/6.0/#sec-allocatearraybuffer' + }, + AllocateTypedArray: { + url: 'https://262.ecma-international.org/6.0/#sec-allocatetypedarray' + }, + ArrayCreate: { + url: 'https://262.ecma-international.org/6.0/#sec-arraycreate' + }, + ArraySetLength: { + url: 'https://262.ecma-international.org/6.0/#sec-arraysetlength' + }, + ArraySpeciesCreate: { + url: 'https://262.ecma-international.org/6.0/#sec-arrayspeciescreate' + }, + BoundFunctionCreate: { + url: 'https://262.ecma-international.org/6.0/#sec-boundfunctioncreate' + }, + Call: { + url: 'https://262.ecma-international.org/6.0/#sec-call' + }, + Canonicalize: { + url: 'https://262.ecma-international.org/6.0/#sec-runtime-semantics-canonicalize-ch' + }, + CanonicalNumericIndexString: { + url: 'https://262.ecma-international.org/6.0/#sec-canonicalnumericindexstring' + }, + CharacterRange: { + url: 'https://262.ecma-international.org/6.0/#sec-runtime-semantics-characterrange-abstract-operation' + }, + CharacterSetMatcher: { + url: 'https://262.ecma-international.org/6.0/#sec-runtime-semantics-charactersetmatcher-abstract-operation' + }, + CloneArrayBuffer: { + url: 'https://262.ecma-international.org/6.0/#sec-clonearraybuffer' + }, + CompletePropertyDescriptor: { + url: 'https://262.ecma-international.org/6.0/#sec-completepropertydescriptor' + }, + Completion: { + url: 'https://262.ecma-international.org/6.0/#sec-implicit-completion-values' + }, + CompletionRecord: { + url: 'https://262.ecma-international.org/6.0/#sec-completion-record-specification-type' + }, + Construct: { + url: 'https://262.ecma-international.org/6.0/#sec-construct' + }, + CopyDataBlockBytes: { + url: 'https://262.ecma-international.org/6.0/#sec-copydatablockbytes' + }, + CreateArrayFromList: { + url: 'https://262.ecma-international.org/6.0/#sec-createarrayfromlist' + }, + CreateArrayIterator: { + url: 'https://262.ecma-international.org/6.0/#sec-createarrayiterator' + }, + CreateBuiltinFunction: { + url: 'https://262.ecma-international.org/6.0/#sec-createbuiltinfunction' + }, + CreateByteDataBlock: { + url: 'https://262.ecma-international.org/6.0/#sec-createbytedatablock' + }, + CreateDataProperty: { + url: 'https://262.ecma-international.org/6.0/#sec-createdataproperty' + }, + CreateDataPropertyOrThrow: { + url: 'https://262.ecma-international.org/6.0/#sec-createdatapropertyorthrow' + }, + CreateDynamicFunction: { + url: 'https://262.ecma-international.org/6.0/#sec-createdynamicfunction' + }, + CreateHTML: { + url: 'https://262.ecma-international.org/6.0/#sec-createhtml' + }, + CreateIntrinsics: { + url: 'https://262.ecma-international.org/6.0/#sec-createintrinsics' + }, + CreateIterResultObject: { + url: 'https://262.ecma-international.org/6.0/#sec-createiterresultobject' + }, + CreateListFromArrayLike: { + url: 'https://262.ecma-international.org/6.0/#sec-createlistfromarraylike' + }, + CreateListIterator: { + url: 'https://262.ecma-international.org/6.0/#sec-createlistiterator' + }, + CreateMapIterator: { + url: 'https://262.ecma-international.org/6.0/#sec-createmapiterator' + }, + CreateMappedArgumentsObject: { + url: 'https://262.ecma-international.org/6.0/#sec-createmappedargumentsobject' + }, + CreateMethodProperty: { + url: 'https://262.ecma-international.org/6.0/#sec-createmethodproperty' + }, + CreatePerIterationEnvironment: { + url: 'https://262.ecma-international.org/6.0/#sec-createperiterationenvironment' + }, + CreateRealm: { + url: 'https://262.ecma-international.org/6.0/#sec-createrealm' + }, + CreateSetIterator: { + url: 'https://262.ecma-international.org/6.0/#sec-createsetiterator' + }, + CreateUnmappedArgumentsObject: { + url: 'https://262.ecma-international.org/6.0/#sec-createunmappedargumentsobject' + }, + DateFromTime: { + url: 'https://262.ecma-international.org/6.0/#sec-date-number' + }, + Day: { + url: 'https://262.ecma-international.org/6.0/#sec-day-number-and-time-within-day' + }, + DayFromYear: { + url: 'https://262.ecma-international.org/6.0/#sec-year-number' + }, + DaylightSavingTA: { + url: 'https://262.ecma-international.org/6.0/#sec-daylight-saving-time-adjustment' + }, + DaysInYear: { + url: 'https://262.ecma-international.org/6.0/#sec-year-number' + }, + DayWithinYear: { + url: 'https://262.ecma-international.org/6.0/#sec-month-number' + }, + Decode: { + url: 'https://262.ecma-international.org/6.0/#sec-decode' + }, + DefinePropertyOrThrow: { + url: 'https://262.ecma-international.org/6.0/#sec-definepropertyorthrow' + }, + DeletePropertyOrThrow: { + url: 'https://262.ecma-international.org/6.0/#sec-deletepropertyorthrow' + }, + DetachArrayBuffer: { + url: 'https://262.ecma-international.org/6.0/#sec-detacharraybuffer' + }, + Encode: { + url: 'https://262.ecma-international.org/6.0/#sec-encode' + }, + EnqueueJob: { + url: 'https://262.ecma-international.org/6.0/#sec-enqueuejob' + }, + EnumerableOwnNames: { + url: 'https://262.ecma-international.org/6.0/#sec-enumerableownnames' + }, + EscapeRegExpPattern: { + url: 'https://262.ecma-international.org/6.0/#sec-escaperegexppattern' + }, + EvalDeclarationInstantiation: { + url: 'https://262.ecma-international.org/6.0/#sec-evaldeclarationinstantiation' + }, + EvaluateCall: { + url: 'https://262.ecma-international.org/6.0/#sec-evaluatecall' + }, + EvaluateDirectCall: { + url: 'https://262.ecma-international.org/6.0/#sec-evaluatedirectcall' + }, + EvaluateNew: { + url: 'https://262.ecma-international.org/6.0/#sec-evaluatenew' + }, + floor: { + url: 'https://262.ecma-international.org/6.0/#sec-algorithm-conventions' + }, + ForBodyEvaluation: { + url: 'https://262.ecma-international.org/6.0/#sec-forbodyevaluation' + }, + 'ForIn/OfBodyEvaluation': { + url: 'https://262.ecma-international.org/6.0/#sec-runtime-semantics-forin-div-ofbodyevaluation-lhs-stmt-iterator-lhskind-labelset' + }, + 'ForIn/OfHeadEvaluation': { + url: 'https://262.ecma-international.org/6.0/#sec-runtime-semantics-forin-div-ofheadevaluation-tdznames-expr-iterationkind' + }, + FromPropertyDescriptor: { + url: 'https://262.ecma-international.org/6.0/#sec-frompropertydescriptor' + }, + FulfillPromise: { + url: 'https://262.ecma-international.org/6.0/#sec-fulfillpromise' + }, + FunctionAllocate: { + url: 'https://262.ecma-international.org/6.0/#sec-functionallocate' + }, + FunctionCreate: { + url: 'https://262.ecma-international.org/6.0/#sec-functioncreate' + }, + FunctionInitialize: { + url: 'https://262.ecma-international.org/6.0/#sec-functioninitialize' + }, + GeneratorFunctionCreate: { + url: 'https://262.ecma-international.org/6.0/#sec-generatorfunctioncreate' + }, + GeneratorResume: { + url: 'https://262.ecma-international.org/6.0/#sec-generatorresume' + }, + GeneratorResumeAbrupt: { + url: 'https://262.ecma-international.org/6.0/#sec-generatorresumeabrupt' + }, + GeneratorStart: { + url: 'https://262.ecma-international.org/6.0/#sec-generatorstart' + }, + GeneratorValidate: { + url: 'https://262.ecma-international.org/6.0/#sec-generatorvalidate' + }, + GeneratorYield: { + url: 'https://262.ecma-international.org/6.0/#sec-generatoryield' + }, + Get: { + url: 'https://262.ecma-international.org/6.0/#sec-get-o-p' + }, + GetBase: { + url: 'https://262.ecma-international.org/6.0/#sec-jobs-and-job-queues' + }, + GetFunctionRealm: { + url: 'https://262.ecma-international.org/6.0/#sec-getfunctionrealm' + }, + GetGlobalObject: { + url: 'https://262.ecma-international.org/6.0/#sec-getglobalobject' + }, + GetIdentifierReference: { + url: 'https://262.ecma-international.org/6.0/#sec-getidentifierreference' + }, + GetIterator: { + url: 'https://262.ecma-international.org/6.0/#sec-getiterator' + }, + GetMethod: { + url: 'https://262.ecma-international.org/6.0/#sec-getmethod' + }, + GetModuleNamespace: { + url: 'https://262.ecma-international.org/6.0/#sec-getmodulenamespace' + }, + GetNewTarget: { + url: 'https://262.ecma-international.org/6.0/#sec-getnewtarget' + }, + GetOwnPropertyKeys: { + url: 'https://262.ecma-international.org/6.0/#sec-getownpropertykeys' + }, + GetPrototypeFromConstructor: { + url: 'https://262.ecma-international.org/6.0/#sec-getprototypefromconstructor' + }, + GetReferencedName: { + url: 'https://262.ecma-international.org/6.0/#sec-jobs-and-job-queues' + }, + GetSubstitution: { + url: 'https://262.ecma-international.org/6.0/#sec-getsubstitution' + }, + GetSuperConstructor: { + url: 'https://262.ecma-international.org/6.0/#sec-getsuperconstructor' + }, + GetTemplateObject: { + url: 'https://262.ecma-international.org/6.0/#sec-gettemplateobject' + }, + GetThisEnvironment: { + url: 'https://262.ecma-international.org/6.0/#sec-getthisenvironment' + }, + GetThisValue: { + url: 'https://262.ecma-international.org/6.0/#sec-getthisvalue' + }, + GetV: { + url: 'https://262.ecma-international.org/6.0/#sec-getv' + }, + GetValue: { + url: 'https://262.ecma-international.org/6.0/#sec-getvalue' + }, + GetValueFromBuffer: { + url: 'https://262.ecma-international.org/6.0/#sec-getvaluefrombuffer' + }, + GetViewValue: { + url: 'https://262.ecma-international.org/6.0/#sec-getviewvalue' + }, + HasOwnProperty: { + url: 'https://262.ecma-international.org/6.0/#sec-hasownproperty' + }, + HasPrimitiveBase: { + url: 'https://262.ecma-international.org/6.0/#sec-jobs-and-job-queues' + }, + HasProperty: { + url: 'https://262.ecma-international.org/6.0/#sec-hasproperty' + }, + HourFromTime: { + url: 'https://262.ecma-international.org/6.0/#sec-hours-minutes-second-and-milliseconds' + }, + ImportedLocalNames: { + url: 'https://262.ecma-international.org/6.0/#sec-importedlocalnames' + }, + InitializeHostDefinedRealm: { + url: 'https://262.ecma-international.org/6.0/#sec-initializehostdefinedrealm' + }, + InitializeReferencedBinding: { + url: 'https://262.ecma-international.org/6.0/#sec-initializereferencedbinding' + }, + InLeapYear: { + url: 'https://262.ecma-international.org/6.0/#sec-year-number' + }, + InstanceofOperator: { + url: 'https://262.ecma-international.org/6.0/#sec-instanceofoperator' + }, + IntegerIndexedElementGet: { + url: 'https://262.ecma-international.org/6.0/#sec-integerindexedelementget' + }, + IntegerIndexedElementSet: { + url: 'https://262.ecma-international.org/6.0/#sec-integerindexedelementset' + }, + IntegerIndexedObjectCreate: { + url: 'https://262.ecma-international.org/6.0/#sec-integerindexedobjectcreate' + }, + InternalizeJSONProperty: { + url: 'https://262.ecma-international.org/6.0/#sec-internalizejsonproperty' + }, + Invoke: { + url: 'https://262.ecma-international.org/6.0/#sec-invoke' + }, + IsAccessorDescriptor: { + url: 'https://262.ecma-international.org/6.0/#sec-isaccessordescriptor' + }, + IsAnonymousFunctionDefinition: { + url: 'https://262.ecma-international.org/6.0/#sec-isanonymousfunctiondefinition' + }, + IsArray: { + url: 'https://262.ecma-international.org/6.0/#sec-isarray' + }, + IsCallable: { + url: 'https://262.ecma-international.org/6.0/#sec-iscallable' + }, + IsCompatiblePropertyDescriptor: { + url: 'https://262.ecma-international.org/6.0/#sec-iscompatiblepropertydescriptor' + }, + IsConcatSpreadable: { + url: 'https://262.ecma-international.org/6.0/#sec-isconcatspreadable' + }, + IsConstructor: { + url: 'https://262.ecma-international.org/6.0/#sec-isconstructor' + }, + IsDataDescriptor: { + url: 'https://262.ecma-international.org/6.0/#sec-isdatadescriptor' + }, + IsDetachedBuffer: { + url: 'https://262.ecma-international.org/6.0/#sec-isdetachedbuffer' + }, + IsExtensible: { + url: 'https://262.ecma-international.org/6.0/#sec-isextensible-o' + }, + IsGenericDescriptor: { + url: 'https://262.ecma-international.org/6.0/#sec-isgenericdescriptor' + }, + IsInTailPosition: { + url: 'https://262.ecma-international.org/6.0/#sec-isintailposition' + }, + IsInteger: { + url: 'https://262.ecma-international.org/6.0/#sec-isinteger' + }, + IsLabelledFunction: { + url: 'https://262.ecma-international.org/6.0/#sec-islabelledfunction' + }, + IsPromise: { + url: 'https://262.ecma-international.org/6.0/#sec-ispromise' + }, + IsPropertyKey: { + url: 'https://262.ecma-international.org/6.0/#sec-ispropertykey' + }, + IsPropertyReference: { + url: 'https://262.ecma-international.org/6.0/#sec-jobs-and-job-queues' + }, + IsRegExp: { + url: 'https://262.ecma-international.org/6.0/#sec-isregexp' + }, + IsStrictReference: { + url: 'https://262.ecma-international.org/6.0/#sec-jobs-and-job-queues' + }, + IsSuperReference: { + url: 'https://262.ecma-international.org/6.0/#sec-jobs-and-job-queues' + }, + IsUnresolvableReference: { + url: 'https://262.ecma-international.org/6.0/#sec-jobs-and-job-queues' + }, + IsWordChar: { + url: 'https://262.ecma-international.org/6.0/#sec-runtime-semantics-iswordchar-abstract-operation' + }, + IteratorClose: { + url: 'https://262.ecma-international.org/6.0/#sec-iteratorclose' + }, + IteratorComplete: { + url: 'https://262.ecma-international.org/6.0/#sec-iteratorcomplete' + }, + IteratorNext: { + url: 'https://262.ecma-international.org/6.0/#sec-iteratornext' + }, + IteratorStep: { + url: 'https://262.ecma-international.org/6.0/#sec-iteratorstep' + }, + IteratorValue: { + url: 'https://262.ecma-international.org/6.0/#sec-iteratorvalue' + }, + LocalTime: { + url: 'https://262.ecma-international.org/6.0/#sec-localtime' + }, + LoopContinues: { + url: 'https://262.ecma-international.org/6.0/#sec-loopcontinues' + }, + MakeArgGetter: { + url: 'https://262.ecma-international.org/6.0/#sec-makearggetter' + }, + MakeArgSetter: { + url: 'https://262.ecma-international.org/6.0/#sec-makeargsetter' + }, + MakeClassConstructor: { + url: 'https://262.ecma-international.org/6.0/#sec-makeclassconstructor' + }, + MakeConstructor: { + url: 'https://262.ecma-international.org/6.0/#sec-makeconstructor' + }, + MakeDate: { + url: 'https://262.ecma-international.org/6.0/#sec-makedate' + }, + MakeDay: { + url: 'https://262.ecma-international.org/6.0/#sec-makeday' + }, + MakeMethod: { + url: 'https://262.ecma-international.org/6.0/#sec-makemethod' + }, + MakeSuperPropertyReference: { + url: 'https://262.ecma-international.org/6.0/#sec-makesuperpropertyreference' + }, + MakeTime: { + url: 'https://262.ecma-international.org/6.0/#sec-maketime' + }, + max: { + url: 'https://262.ecma-international.org/6.0/#sec-algorithm-conventions' + }, + min: { + url: 'https://262.ecma-international.org/6.0/#sec-algorithm-conventions' + }, + MinFromTime: { + url: 'https://262.ecma-international.org/6.0/#sec-hours-minutes-second-and-milliseconds' + }, + ModuleNamespaceCreate: { + url: 'https://262.ecma-international.org/6.0/#sec-modulenamespacecreate' + }, + modulo: { + url: 'https://262.ecma-international.org/6.0/#sec-algorithm-conventions' + }, + MonthFromTime: { + url: 'https://262.ecma-international.org/6.0/#sec-month-number' + }, + msFromTime: { + url: 'https://262.ecma-international.org/6.0/#sec-hours-minutes-second-and-milliseconds' + }, + msPerDay: { + url: 'https://262.ecma-international.org/6.0/#sec-day-number-and-time-within-day' + }, + NewDeclarativeEnvironment: { + url: 'https://262.ecma-international.org/6.0/#sec-newdeclarativeenvironment' + }, + NewFunctionEnvironment: { + url: 'https://262.ecma-international.org/6.0/#sec-newfunctionenvironment' + }, + NewGlobalEnvironment: { + url: 'https://262.ecma-international.org/6.0/#sec-newglobalenvironment' + }, + NewModuleEnvironment: { + url: 'https://262.ecma-international.org/6.0/#sec-newmoduleenvironment' + }, + NewObjectEnvironment: { + url: 'https://262.ecma-international.org/6.0/#sec-newobjectenvironment' + }, + NewPromiseCapability: { + url: 'https://262.ecma-international.org/6.0/#sec-newpromisecapability' + }, + NormalCompletion: { + url: 'https://262.ecma-international.org/6.0/#sec-normalcompletion' + }, + ObjectCreate: { + url: 'https://262.ecma-international.org/6.0/#sec-objectcreate' + }, + ObjectDefineProperties: { + url: 'https://262.ecma-international.org/6.0/#sec-objectdefineproperties' + }, + OrdinaryCallBindThis: { + url: 'https://262.ecma-international.org/6.0/#sec-ordinarycallbindthis' + }, + OrdinaryCallEvaluateBody: { + url: 'https://262.ecma-international.org/6.0/#sec-ordinarycallevaluatebody' + }, + OrdinaryCreateFromConstructor: { + url: 'https://262.ecma-international.org/6.0/#sec-ordinarycreatefromconstructor' + }, + OrdinaryDefineOwnProperty: { + url: 'https://262.ecma-international.org/6.0/#sec-ordinarydefineownproperty' + }, + OrdinaryGetOwnProperty: { + url: 'https://262.ecma-international.org/6.0/#sec-ordinarygetownproperty' + }, + OrdinaryHasInstance: { + url: 'https://262.ecma-international.org/6.0/#sec-ordinaryhasinstance' + }, + OrdinaryHasProperty: { + url: 'https://262.ecma-international.org/6.0/#sec-ordinaryhasproperty' + }, + ParseModule: { + url: 'https://262.ecma-international.org/6.0/#sec-parsemodule' + }, + PerformEval: { + url: 'https://262.ecma-international.org/6.0/#sec-performeval' + }, + PerformPromiseAll: { + url: 'https://262.ecma-international.org/6.0/#sec-performpromiseall' + }, + PerformPromiseRace: { + url: 'https://262.ecma-international.org/6.0/#sec-performpromiserace' + }, + PerformPromiseThen: { + url: 'https://262.ecma-international.org/6.0/#sec-performpromisethen' + }, + PrepareForOrdinaryCall: { + url: 'https://262.ecma-international.org/6.0/#sec-prepareforordinarycall' + }, + PrepareForTailCall: { + url: 'https://262.ecma-international.org/6.0/#sec-preparefortailcall' + }, + ProxyCreate: { + url: 'https://262.ecma-international.org/6.0/#sec-proxycreate' + }, + PutValue: { + url: 'https://262.ecma-international.org/6.0/#sec-putvalue' + }, + QuoteJSONString: { + url: 'https://262.ecma-international.org/6.0/#sec-quotejsonstring' + }, + RegExpAlloc: { + url: 'https://262.ecma-international.org/6.0/#sec-regexpalloc' + }, + RegExpBuiltinExec: { + url: 'https://262.ecma-international.org/6.0/#sec-regexpbuiltinexec' + }, + RegExpCreate: { + url: 'https://262.ecma-international.org/6.0/#sec-regexpcreate' + }, + RegExpExec: { + url: 'https://262.ecma-international.org/6.0/#sec-regexpexec' + }, + RegExpInitialize: { + url: 'https://262.ecma-international.org/6.0/#sec-regexpinitialize' + }, + RejectPromise: { + url: 'https://262.ecma-international.org/6.0/#sec-rejectpromise' + }, + RepeatMatcher: { + url: 'https://262.ecma-international.org/6.0/#sec-runtime-semantics-repeatmatcher-abstract-operation' + }, + RequireObjectCoercible: { + url: 'https://262.ecma-international.org/6.0/#sec-requireobjectcoercible' + }, + ResolveBinding: { + url: 'https://262.ecma-international.org/6.0/#sec-resolvebinding' + }, + ResolveThisBinding: { + url: 'https://262.ecma-international.org/6.0/#sec-resolvethisbinding' + }, + SameValue: { + url: 'https://262.ecma-international.org/6.0/#sec-samevalue' + }, + SameValueZero: { + url: 'https://262.ecma-international.org/6.0/#sec-samevaluezero' + }, + SecFromTime: { + url: 'https://262.ecma-international.org/6.0/#sec-hours-minutes-second-and-milliseconds' + }, + SerializeJSONArray: { + url: 'https://262.ecma-international.org/6.0/#sec-serializejsonarray' + }, + SerializeJSONObject: { + url: 'https://262.ecma-international.org/6.0/#sec-serializejsonobject' + }, + SerializeJSONProperty: { + url: 'https://262.ecma-international.org/6.0/#sec-serializejsonproperty' + }, + Set: { + url: 'https://262.ecma-international.org/6.0/#sec-set-o-p-v-throw' + }, + SetDefaultGlobalBindings: { + url: 'https://262.ecma-international.org/6.0/#sec-setdefaultglobalbindings' + }, + SetFunctionName: { + url: 'https://262.ecma-international.org/6.0/#sec-setfunctionname' + }, + SetIntegrityLevel: { + url: 'https://262.ecma-international.org/6.0/#sec-setintegritylevel' + }, + SetRealmGlobalObject: { + url: 'https://262.ecma-international.org/6.0/#sec-setrealmglobalobject' + }, + SetValueInBuffer: { + url: 'https://262.ecma-international.org/6.0/#sec-setvalueinbuffer' + }, + SetViewValue: { + url: 'https://262.ecma-international.org/6.0/#sec-setviewvalue' + }, + sign: { + url: 'https://262.ecma-international.org/6.0/#sec-algorithm-conventions' + }, + SortCompare: { + url: 'https://262.ecma-international.org/6.0/#sec-sortcompare' + }, + SpeciesConstructor: { + url: 'https://262.ecma-international.org/6.0/#sec-speciesconstructor' + }, + SplitMatch: { + url: 'https://262.ecma-international.org/6.0/#sec-splitmatch' + }, + 'Strict Equality Comparison': { + url: 'https://262.ecma-international.org/6.0/#sec-strict-equality-comparison' + }, + StringCreate: { + url: 'https://262.ecma-international.org/6.0/#sec-stringcreate' + }, + StringGetIndexProperty: { + url: 'https://262.ecma-international.org/6.0/#sec-stringgetindexproperty' + }, + SymbolDescriptiveString: { + url: 'https://262.ecma-international.org/6.0/#sec-symboldescriptivestring' + }, + TestIntegrityLevel: { + url: 'https://262.ecma-international.org/6.0/#sec-testintegritylevel' + }, + thisBooleanValue: { + url: 'https://262.ecma-international.org/6.0/#sec-properties-of-the-boolean-prototype-object' + }, + thisNumberValue: { + url: 'https://262.ecma-international.org/6.0/#sec-properties-of-the-number-prototype-object' + }, + thisStringValue: { + url: 'https://262.ecma-international.org/6.0/#sec-properties-of-the-string-prototype-object' + }, + thisTimeValue: { + url: 'https://262.ecma-international.org/6.0/#sec-properties-of-the-date-prototype-object' + }, + TimeClip: { + url: 'https://262.ecma-international.org/6.0/#sec-timeclip' + }, + TimeFromYear: { + url: 'https://262.ecma-international.org/6.0/#sec-year-number' + }, + TimeWithinDay: { + url: 'https://262.ecma-international.org/6.0/#sec-day-number-and-time-within-day' + }, + ToBoolean: { + url: 'https://262.ecma-international.org/6.0/#sec-toboolean' + }, + ToDateString: { + url: 'https://262.ecma-international.org/6.0/#sec-todatestring' + }, + ToInt16: { + url: 'https://262.ecma-international.org/6.0/#sec-toint16' + }, + ToInt32: { + url: 'https://262.ecma-international.org/6.0/#sec-toint32' + }, + ToInt8: { + url: 'https://262.ecma-international.org/6.0/#sec-toint8' + }, + ToInteger: { + url: 'https://262.ecma-international.org/6.0/#sec-tointeger' + }, + ToLength: { + url: 'https://262.ecma-international.org/6.0/#sec-tolength' + }, + ToNumber: { + url: 'https://262.ecma-international.org/6.0/#sec-tonumber' + }, + ToObject: { + url: 'https://262.ecma-international.org/6.0/#sec-toobject' + }, + ToPrimitive: { + url: 'https://262.ecma-international.org/6.0/#sec-toprimitive' + }, + ToPropertyDescriptor: { + url: 'https://262.ecma-international.org/6.0/#sec-topropertydescriptor' + }, + ToPropertyKey: { + url: 'https://262.ecma-international.org/6.0/#sec-topropertykey' + }, + ToString: { + url: 'https://262.ecma-international.org/6.0/#sec-tostring' + }, + ToUint16: { + url: 'https://262.ecma-international.org/6.0/#sec-touint16' + }, + ToUint32: { + url: 'https://262.ecma-international.org/6.0/#sec-touint32' + }, + ToUint8: { + url: 'https://262.ecma-international.org/6.0/#sec-touint8' + }, + ToUint8Clamp: { + url: 'https://262.ecma-international.org/6.0/#sec-touint8clamp' + }, + TriggerPromiseReactions: { + url: 'https://262.ecma-international.org/6.0/#sec-triggerpromisereactions' + }, + Type: { + url: 'https://262.ecma-international.org/6.0/#sec-ecmascript-data-types-and-values' + }, + TypedArrayFrom: { + url: 'https://262.ecma-international.org/6.0/#sec-typedarrayfrom' + }, + UpdateEmpty: { + url: 'https://262.ecma-international.org/6.0/#sec-updateempty' + }, + UTC: { + url: 'https://262.ecma-international.org/6.0/#sec-utc-t' + }, + ValidateAndApplyPropertyDescriptor: { + url: 'https://262.ecma-international.org/6.0/#sec-validateandapplypropertydescriptor' + }, + ValidateTypedArray: { + url: 'https://262.ecma-international.org/6.0/#sec-validatetypedarray' + }, + WeekDay: { + url: 'https://262.ecma-international.org/6.0/#sec-week-day' + }, + YearFromTime: { + url: 'https://262.ecma-international.org/6.0/#sec-year-number' + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2016.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2016.js new file mode 100644 index 0000000000000000000000000000000000000000..66e6d4afc85345378fd784b74fb8afc870dc3c99 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2016.js @@ -0,0 +1,813 @@ +'use strict'; + +module.exports = { + IsPropertyDescriptor: 'https://262.ecma-international.org/6.0/#sec-property-descriptor-specification-type', // not actually an abstract op + + abs: { + url: 'https://262.ecma-international.org/7.0/#sec-algorithm-conventions' + }, + 'Abstract Equality Comparison': { + url: 'https://262.ecma-international.org/7.0/#sec-abstract-equality-comparison' + }, + 'Abstract Relational Comparison': { + url: 'https://262.ecma-international.org/7.0/#sec-abstract-relational-comparison' + }, + AddRestrictedFunctionProperties: { + url: 'https://262.ecma-international.org/7.0/#sec-addrestrictedfunctionproperties' + }, + AdvanceStringIndex: { + url: 'https://262.ecma-international.org/7.0/#sec-advancestringindex' + }, + AllocateArrayBuffer: { + url: 'https://262.ecma-international.org/7.0/#sec-allocatearraybuffer' + }, + AllocateTypedArray: { + url: 'https://262.ecma-international.org/7.0/#sec-allocatetypedarray' + }, + AllocateTypedArrayBuffer: { + url: 'https://262.ecma-international.org/7.0/#sec-allocatetypedarraybuffer' + }, + ArrayCreate: { + url: 'https://262.ecma-international.org/7.0/#sec-arraycreate' + }, + ArraySetLength: { + url: 'https://262.ecma-international.org/7.0/#sec-arraysetlength' + }, + ArraySpeciesCreate: { + url: 'https://262.ecma-international.org/7.0/#sec-arrayspeciescreate' + }, + BlockDeclarationInstantiation: { + url: 'https://262.ecma-international.org/7.0/#sec-blockdeclarationinstantiation' + }, + BoundFunctionCreate: { + url: 'https://262.ecma-international.org/7.0/#sec-boundfunctioncreate' + }, + Call: { + url: 'https://262.ecma-international.org/7.0/#sec-call' + }, + Canonicalize: { + url: 'https://262.ecma-international.org/7.0/#sec-runtime-semantics-canonicalize-ch' + }, + CanonicalNumericIndexString: { + url: 'https://262.ecma-international.org/7.0/#sec-canonicalnumericindexstring' + }, + CharacterRange: { + url: 'https://262.ecma-international.org/7.0/#sec-runtime-semantics-characterrange-abstract-operation' + }, + CharacterRangeOrUnion: { + url: 'https://262.ecma-international.org/7.0/#sec-runtime-semantics-characterrangeorunion-abstract-operation' + }, + CharacterSetMatcher: { + url: 'https://262.ecma-international.org/7.0/#sec-runtime-semantics-charactersetmatcher-abstract-operation' + }, + CloneArrayBuffer: { + url: 'https://262.ecma-international.org/7.0/#sec-clonearraybuffer' + }, + CompletePropertyDescriptor: { + url: 'https://262.ecma-international.org/7.0/#sec-completepropertydescriptor' + }, + Completion: { + url: 'https://262.ecma-international.org/7.0/#sec-completion-record-specification-type' + }, + CompletionRecord: { + url: 'https://262.ecma-international.org/7.0/#sec-completion-record-specification-type' + }, + Construct: { + url: 'https://262.ecma-international.org/7.0/#sec-construct' + }, + CopyDataBlockBytes: { + url: 'https://262.ecma-international.org/7.0/#sec-copydatablockbytes' + }, + CreateArrayFromList: { + url: 'https://262.ecma-international.org/7.0/#sec-createarrayfromlist' + }, + CreateArrayIterator: { + url: 'https://262.ecma-international.org/7.0/#sec-createarrayiterator' + }, + CreateBuiltinFunction: { + url: 'https://262.ecma-international.org/7.0/#sec-createbuiltinfunction' + }, + CreateByteDataBlock: { + url: 'https://262.ecma-international.org/7.0/#sec-createbytedatablock' + }, + CreateDataProperty: { + url: 'https://262.ecma-international.org/7.0/#sec-createdataproperty' + }, + CreateDataPropertyOrThrow: { + url: 'https://262.ecma-international.org/7.0/#sec-createdatapropertyorthrow' + }, + CreateDynamicFunction: { + url: 'https://262.ecma-international.org/7.0/#sec-createdynamicfunction' + }, + CreateHTML: { + url: 'https://262.ecma-international.org/7.0/#sec-createhtml' + }, + CreateIntrinsics: { + url: 'https://262.ecma-international.org/7.0/#sec-createintrinsics' + }, + CreateIterResultObject: { + url: 'https://262.ecma-international.org/7.0/#sec-createiterresultobject' + }, + CreateListFromArrayLike: { + url: 'https://262.ecma-international.org/7.0/#sec-createlistfromarraylike' + }, + CreateListIterator: { + url: 'https://262.ecma-international.org/7.0/#sec-createlistiterator' + }, + CreateMapIterator: { + url: 'https://262.ecma-international.org/7.0/#sec-createmapiterator' + }, + CreateMappedArgumentsObject: { + url: 'https://262.ecma-international.org/7.0/#sec-createmappedargumentsobject' + }, + CreateMethodProperty: { + url: 'https://262.ecma-international.org/7.0/#sec-createmethodproperty' + }, + CreatePerIterationEnvironment: { + url: 'https://262.ecma-international.org/7.0/#sec-createperiterationenvironment' + }, + CreateRealm: { + url: 'https://262.ecma-international.org/7.0/#sec-createrealm' + }, + CreateResolvingFunctions: { + url: 'https://262.ecma-international.org/7.0/#sec-createresolvingfunctions' + }, + CreateSetIterator: { + url: 'https://262.ecma-international.org/7.0/#sec-createsetiterator' + }, + CreateStringIterator: { + url: 'https://262.ecma-international.org/7.0/#sec-createstringiterator' + }, + CreateUnmappedArgumentsObject: { + url: 'https://262.ecma-international.org/7.0/#sec-createunmappedargumentsobject' + }, + DateFromTime: { + url: 'https://262.ecma-international.org/7.0/#sec-date-number' + }, + Day: { + url: 'https://262.ecma-international.org/7.0/#sec-day-number-and-time-within-day' + }, + DayFromYear: { + url: 'https://262.ecma-international.org/7.0/#sec-year-number' + }, + DaylightSavingTA: { + url: 'https://262.ecma-international.org/7.0/#sec-daylight-saving-time-adjustment' + }, + DaysInYear: { + url: 'https://262.ecma-international.org/7.0/#sec-year-number' + }, + DayWithinYear: { + url: 'https://262.ecma-international.org/7.0/#sec-month-number' + }, + Decode: { + url: 'https://262.ecma-international.org/7.0/#sec-decode' + }, + DefinePropertyOrThrow: { + url: 'https://262.ecma-international.org/7.0/#sec-definepropertyorthrow' + }, + DeletePropertyOrThrow: { + url: 'https://262.ecma-international.org/7.0/#sec-deletepropertyorthrow' + }, + DetachArrayBuffer: { + url: 'https://262.ecma-international.org/7.0/#sec-detacharraybuffer' + }, + Encode: { + url: 'https://262.ecma-international.org/7.0/#sec-encode' + }, + EnqueueJob: { + url: 'https://262.ecma-international.org/7.0/#sec-enqueuejob' + }, + EnumerableOwnNames: { + url: 'https://262.ecma-international.org/7.0/#sec-enumerableownnames' + }, + EnumerateObjectProperties: { + url: 'https://262.ecma-international.org/7.0/#sec-enumerate-object-properties' + }, + EscapeRegExpPattern: { + url: 'https://262.ecma-international.org/7.0/#sec-escaperegexppattern' + }, + EvalDeclarationInstantiation: { + url: 'https://262.ecma-international.org/7.0/#sec-evaldeclarationinstantiation' + }, + EvaluateCall: { + url: 'https://262.ecma-international.org/7.0/#sec-evaluatecall' + }, + EvaluateDirectCall: { + url: 'https://262.ecma-international.org/7.0/#sec-evaluatedirectcall' + }, + EvaluateNew: { + url: 'https://262.ecma-international.org/7.0/#sec-evaluatenew' + }, + floor: { + url: 'https://262.ecma-international.org/7.0/#sec-algorithm-conventions' + }, + ForBodyEvaluation: { + url: 'https://262.ecma-international.org/7.0/#sec-forbodyevaluation' + }, + 'ForIn/OfBodyEvaluation': { + url: 'https://262.ecma-international.org/7.0/#sec-runtime-semantics-forin-div-ofbodyevaluation-lhs-stmt-iterator-lhskind-labelset' + }, + 'ForIn/OfHeadEvaluation': { + url: 'https://262.ecma-international.org/7.0/#sec-runtime-semantics-forin-div-ofheadevaluation-tdznames-expr-iterationkind' + }, + FromPropertyDescriptor: { + url: 'https://262.ecma-international.org/7.0/#sec-frompropertydescriptor' + }, + FulfillPromise: { + url: 'https://262.ecma-international.org/7.0/#sec-fulfillpromise' + }, + FunctionAllocate: { + url: 'https://262.ecma-international.org/7.0/#sec-functionallocate' + }, + FunctionCreate: { + url: 'https://262.ecma-international.org/7.0/#sec-functioncreate' + }, + FunctionDeclarationInstantiation: { + url: 'https://262.ecma-international.org/7.0/#sec-functiondeclarationinstantiation' + }, + FunctionInitialize: { + url: 'https://262.ecma-international.org/7.0/#sec-functioninitialize' + }, + GeneratorFunctionCreate: { + url: 'https://262.ecma-international.org/7.0/#sec-generatorfunctioncreate' + }, + GeneratorResume: { + url: 'https://262.ecma-international.org/7.0/#sec-generatorresume' + }, + GeneratorResumeAbrupt: { + url: 'https://262.ecma-international.org/7.0/#sec-generatorresumeabrupt' + }, + GeneratorStart: { + url: 'https://262.ecma-international.org/7.0/#sec-generatorstart' + }, + GeneratorValidate: { + url: 'https://262.ecma-international.org/7.0/#sec-generatorvalidate' + }, + GeneratorYield: { + url: 'https://262.ecma-international.org/7.0/#sec-generatoryield' + }, + Get: { + url: 'https://262.ecma-international.org/7.0/#sec-get-o-p' + }, + GetActiveScriptOrModule: { + url: 'https://262.ecma-international.org/7.0/#sec-getactivescriptormodule' + }, + GetFunctionRealm: { + url: 'https://262.ecma-international.org/7.0/#sec-getfunctionrealm' + }, + GetGlobalObject: { + url: 'https://262.ecma-international.org/7.0/#sec-getglobalobject' + }, + GetIdentifierReference: { + url: 'https://262.ecma-international.org/7.0/#sec-getidentifierreference' + }, + GetIterator: { + url: 'https://262.ecma-international.org/7.0/#sec-getiterator' + }, + GetMethod: { + url: 'https://262.ecma-international.org/7.0/#sec-getmethod' + }, + GetModuleNamespace: { + url: 'https://262.ecma-international.org/7.0/#sec-getmodulenamespace' + }, + GetNewTarget: { + url: 'https://262.ecma-international.org/7.0/#sec-getnewtarget' + }, + GetOwnPropertyKeys: { + url: 'https://262.ecma-international.org/7.0/#sec-getownpropertykeys' + }, + GetPrototypeFromConstructor: { + url: 'https://262.ecma-international.org/7.0/#sec-getprototypefromconstructor' + }, + GetSubstitution: { + url: 'https://262.ecma-international.org/7.0/#sec-getsubstitution' + }, + GetSuperConstructor: { + url: 'https://262.ecma-international.org/7.0/#sec-getsuperconstructor' + }, + GetTemplateObject: { + url: 'https://262.ecma-international.org/7.0/#sec-gettemplateobject' + }, + GetThisEnvironment: { + url: 'https://262.ecma-international.org/7.0/#sec-getthisenvironment' + }, + GetThisValue: { + url: 'https://262.ecma-international.org/7.0/#sec-getthisvalue' + }, + GetV: { + url: 'https://262.ecma-international.org/7.0/#sec-getv' + }, + GetValue: { + url: 'https://262.ecma-international.org/7.0/#sec-getvalue' + }, + GetValueFromBuffer: { + url: 'https://262.ecma-international.org/7.0/#sec-getvaluefrombuffer' + }, + GetViewValue: { + url: 'https://262.ecma-international.org/7.0/#sec-getviewvalue' + }, + GlobalDeclarationInstantiation: { + url: 'https://262.ecma-international.org/7.0/#sec-globaldeclarationinstantiation' + }, + HasOwnProperty: { + url: 'https://262.ecma-international.org/7.0/#sec-hasownproperty' + }, + HasProperty: { + url: 'https://262.ecma-international.org/7.0/#sec-hasproperty' + }, + HourFromTime: { + url: 'https://262.ecma-international.org/7.0/#sec-hours-minutes-second-and-milliseconds' + }, + IfAbruptRejectPromise: { + url: 'https://262.ecma-international.org/7.0/#sec-ifabruptrejectpromise' + }, + ImportedLocalNames: { + url: 'https://262.ecma-international.org/7.0/#sec-importedlocalnames' + }, + InitializeBoundName: { + url: 'https://262.ecma-international.org/7.0/#sec-initializeboundname' + }, + InitializeHostDefinedRealm: { + url: 'https://262.ecma-international.org/7.0/#sec-initializehostdefinedrealm' + }, + InitializeReferencedBinding: { + url: 'https://262.ecma-international.org/7.0/#sec-initializereferencedbinding' + }, + InLeapYear: { + url: 'https://262.ecma-international.org/7.0/#sec-year-number' + }, + InstanceofOperator: { + url: 'https://262.ecma-international.org/7.0/#sec-instanceofoperator' + }, + IntegerIndexedElementGet: { + url: 'https://262.ecma-international.org/7.0/#sec-integerindexedelementget' + }, + IntegerIndexedElementSet: { + url: 'https://262.ecma-international.org/7.0/#sec-integerindexedelementset' + }, + IntegerIndexedObjectCreate: { + url: 'https://262.ecma-international.org/7.0/#sec-integerindexedobjectcreate' + }, + InternalizeJSONProperty: { + url: 'https://262.ecma-international.org/7.0/#sec-internalizejsonproperty' + }, + Invoke: { + url: 'https://262.ecma-international.org/7.0/#sec-invoke' + }, + IsAccessorDescriptor: { + url: 'https://262.ecma-international.org/7.0/#sec-isaccessordescriptor' + }, + IsAnonymousFunctionDefinition: { + url: 'https://262.ecma-international.org/7.0/#sec-isanonymousfunctiondefinition' + }, + IsArray: { + url: 'https://262.ecma-international.org/7.0/#sec-isarray' + }, + IsCallable: { + url: 'https://262.ecma-international.org/7.0/#sec-iscallable' + }, + IsCompatiblePropertyDescriptor: { + url: 'https://262.ecma-international.org/7.0/#sec-iscompatiblepropertydescriptor' + }, + IsConcatSpreadable: { + url: 'https://262.ecma-international.org/7.0/#sec-isconcatspreadable' + }, + IsConstructor: { + url: 'https://262.ecma-international.org/7.0/#sec-isconstructor' + }, + IsDataDescriptor: { + url: 'https://262.ecma-international.org/7.0/#sec-isdatadescriptor' + }, + IsDetachedBuffer: { + url: 'https://262.ecma-international.org/7.0/#sec-isdetachedbuffer' + }, + IsExtensible: { + url: 'https://262.ecma-international.org/7.0/#sec-isextensible-o' + }, + IsGenericDescriptor: { + url: 'https://262.ecma-international.org/7.0/#sec-isgenericdescriptor' + }, + IsInTailPosition: { + url: 'https://262.ecma-international.org/7.0/#sec-isintailposition' + }, + IsInteger: { + url: 'https://262.ecma-international.org/7.0/#sec-isinteger' + }, + IsLabelledFunction: { + url: 'https://262.ecma-international.org/7.0/#sec-islabelledfunction' + }, + IsPromise: { + url: 'https://262.ecma-international.org/7.0/#sec-ispromise' + }, + IsPropertyKey: { + url: 'https://262.ecma-international.org/7.0/#sec-ispropertykey' + }, + IsRegExp: { + url: 'https://262.ecma-international.org/7.0/#sec-isregexp' + }, + IsWordChar: { + url: 'https://262.ecma-international.org/7.0/#sec-runtime-semantics-iswordchar-abstract-operation' + }, + IterableToArrayLike: { + url: 'https://262.ecma-international.org/7.0/#sec-iterabletoarraylike' + }, + IteratorClose: { + url: 'https://262.ecma-international.org/7.0/#sec-iteratorclose' + }, + IteratorComplete: { + url: 'https://262.ecma-international.org/7.0/#sec-iteratorcomplete' + }, + IteratorNext: { + url: 'https://262.ecma-international.org/7.0/#sec-iteratornext' + }, + IteratorStep: { + url: 'https://262.ecma-international.org/7.0/#sec-iteratorstep' + }, + IteratorValue: { + url: 'https://262.ecma-international.org/7.0/#sec-iteratorvalue' + }, + LocalTime: { + url: 'https://262.ecma-international.org/7.0/#sec-localtime' + }, + LoopContinues: { + url: 'https://262.ecma-international.org/7.0/#sec-loopcontinues' + }, + MakeArgGetter: { + url: 'https://262.ecma-international.org/7.0/#sec-makearggetter' + }, + MakeArgSetter: { + url: 'https://262.ecma-international.org/7.0/#sec-makeargsetter' + }, + MakeClassConstructor: { + url: 'https://262.ecma-international.org/7.0/#sec-makeclassconstructor' + }, + MakeConstructor: { + url: 'https://262.ecma-international.org/7.0/#sec-makeconstructor' + }, + MakeDate: { + url: 'https://262.ecma-international.org/7.0/#sec-makedate' + }, + MakeDay: { + url: 'https://262.ecma-international.org/7.0/#sec-makeday' + }, + MakeMethod: { + url: 'https://262.ecma-international.org/7.0/#sec-makemethod' + }, + MakeSuperPropertyReference: { + url: 'https://262.ecma-international.org/7.0/#sec-makesuperpropertyreference' + }, + MakeTime: { + url: 'https://262.ecma-international.org/7.0/#sec-maketime' + }, + max: { + url: 'https://262.ecma-international.org/7.0/#sec-algorithm-conventions' + }, + min: { + url: 'https://262.ecma-international.org/7.0/#sec-algorithm-conventions' + }, + MinFromTime: { + url: 'https://262.ecma-international.org/7.0/#sec-hours-minutes-second-and-milliseconds' + }, + ModuleNamespaceCreate: { + url: 'https://262.ecma-international.org/7.0/#sec-modulenamespacecreate' + }, + modulo: { + url: 'https://262.ecma-international.org/7.0/#sec-algorithm-conventions' + }, + MonthFromTime: { + url: 'https://262.ecma-international.org/7.0/#sec-month-number' + }, + msFromTime: { + url: 'https://262.ecma-international.org/7.0/#sec-hours-minutes-second-and-milliseconds' + }, + NewDeclarativeEnvironment: { + url: 'https://262.ecma-international.org/7.0/#sec-newdeclarativeenvironment' + }, + NewFunctionEnvironment: { + url: 'https://262.ecma-international.org/7.0/#sec-newfunctionenvironment' + }, + NewGlobalEnvironment: { + url: 'https://262.ecma-international.org/7.0/#sec-newglobalenvironment' + }, + NewModuleEnvironment: { + url: 'https://262.ecma-international.org/7.0/#sec-newmoduleenvironment' + }, + NewObjectEnvironment: { + url: 'https://262.ecma-international.org/7.0/#sec-newobjectenvironment' + }, + NewPromiseCapability: { + url: 'https://262.ecma-international.org/7.0/#sec-newpromisecapability' + }, + NextJob: { + url: 'https://262.ecma-international.org/7.0/#sec-nextjob-result' + }, + NormalCompletion: { + url: 'https://262.ecma-international.org/7.0/#sec-normalcompletion' + }, + ObjectCreate: { + url: 'https://262.ecma-international.org/7.0/#sec-objectcreate' + }, + ObjectDefineProperties: { + url: 'https://262.ecma-international.org/7.0/#sec-objectdefineproperties' + }, + OrdinaryCallBindThis: { + url: 'https://262.ecma-international.org/7.0/#sec-ordinarycallbindthis' + }, + OrdinaryCallEvaluateBody: { + url: 'https://262.ecma-international.org/7.0/#sec-ordinarycallevaluatebody' + }, + OrdinaryCreateFromConstructor: { + url: 'https://262.ecma-international.org/7.0/#sec-ordinarycreatefromconstructor' + }, + OrdinaryDefineOwnProperty: { + url: 'https://262.ecma-international.org/7.0/#sec-ordinarydefineownproperty' + }, + OrdinaryDelete: { + url: 'https://262.ecma-international.org/7.0/#sec-ordinarydelete' + }, + OrdinaryGet: { + url: 'https://262.ecma-international.org/7.0/#sec-ordinaryget' + }, + OrdinaryGetOwnProperty: { + url: 'https://262.ecma-international.org/7.0/#sec-ordinarygetownproperty' + }, + OrdinaryGetPrototypeOf: { + url: 'https://262.ecma-international.org/7.0/#sec-ordinarygetprototypeof' + }, + OrdinaryHasInstance: { + url: 'https://262.ecma-international.org/7.0/#sec-ordinaryhasinstance' + }, + OrdinaryHasProperty: { + url: 'https://262.ecma-international.org/7.0/#sec-ordinaryhasproperty' + }, + OrdinaryIsExtensible: { + url: 'https://262.ecma-international.org/7.0/#sec-ordinaryisextensible' + }, + OrdinaryOwnPropertyKeys: { + url: 'https://262.ecma-international.org/7.0/#sec-ordinaryownpropertykeys' + }, + OrdinaryPreventExtensions: { + url: 'https://262.ecma-international.org/7.0/#sec-ordinarypreventextensions' + }, + OrdinarySet: { + url: 'https://262.ecma-international.org/7.0/#sec-ordinaryset' + }, + OrdinarySetPrototypeOf: { + url: 'https://262.ecma-international.org/7.0/#sec-ordinarysetprototypeof' + }, + ParseModule: { + url: 'https://262.ecma-international.org/7.0/#sec-parsemodule' + }, + ParseScript: { + url: 'https://262.ecma-international.org/7.0/#sec-parse-script' + }, + PerformEval: { + url: 'https://262.ecma-international.org/7.0/#sec-performeval' + }, + PerformPromiseAll: { + url: 'https://262.ecma-international.org/7.0/#sec-performpromiseall' + }, + PerformPromiseRace: { + url: 'https://262.ecma-international.org/7.0/#sec-performpromiserace' + }, + PerformPromiseThen: { + url: 'https://262.ecma-international.org/7.0/#sec-performpromisethen' + }, + PrepareForOrdinaryCall: { + url: 'https://262.ecma-international.org/7.0/#sec-prepareforordinarycall' + }, + PrepareForTailCall: { + url: 'https://262.ecma-international.org/7.0/#sec-preparefortailcall' + }, + PromiseReactionJob: { + url: 'https://262.ecma-international.org/7.0/#sec-promisereactionjob' + }, + PromiseResolveThenableJob: { + url: 'https://262.ecma-international.org/7.0/#sec-promiseresolvethenablejob' + }, + ProxyCreate: { + url: 'https://262.ecma-international.org/7.0/#sec-proxycreate' + }, + PutValue: { + url: 'https://262.ecma-international.org/7.0/#sec-putvalue' + }, + QuoteJSONString: { + url: 'https://262.ecma-international.org/7.0/#sec-quotejsonstring' + }, + RegExpAlloc: { + url: 'https://262.ecma-international.org/7.0/#sec-regexpalloc' + }, + RegExpBuiltinExec: { + url: 'https://262.ecma-international.org/7.0/#sec-regexpbuiltinexec' + }, + RegExpCreate: { + url: 'https://262.ecma-international.org/7.0/#sec-regexpcreate' + }, + RegExpExec: { + url: 'https://262.ecma-international.org/7.0/#sec-regexpexec' + }, + RegExpInitialize: { + url: 'https://262.ecma-international.org/7.0/#sec-regexpinitialize' + }, + RejectPromise: { + url: 'https://262.ecma-international.org/7.0/#sec-rejectpromise' + }, + RepeatMatcher: { + url: 'https://262.ecma-international.org/7.0/#sec-runtime-semantics-repeatmatcher-abstract-operation' + }, + RequireObjectCoercible: { + url: 'https://262.ecma-international.org/7.0/#sec-requireobjectcoercible' + }, + ResolveBinding: { + url: 'https://262.ecma-international.org/7.0/#sec-resolvebinding' + }, + ResolveThisBinding: { + url: 'https://262.ecma-international.org/7.0/#sec-resolvethisbinding' + }, + ReturnIfAbrupt: { + url: 'https://262.ecma-international.org/7.0/#sec-returnifabrupt' + }, + SameValue: { + url: 'https://262.ecma-international.org/7.0/#sec-samevalue' + }, + SameValueNonNumber: { + url: 'https://262.ecma-international.org/7.0/#sec-samevaluenonnumber' + }, + SameValueZero: { + url: 'https://262.ecma-international.org/7.0/#sec-samevaluezero' + }, + ScriptEvaluation: { + url: 'https://262.ecma-international.org/7.0/#sec-runtime-semantics-scriptevaluation' + }, + ScriptEvaluationJob: { + url: 'https://262.ecma-international.org/7.0/#sec-scriptevaluationjob' + }, + SecFromTime: { + url: 'https://262.ecma-international.org/7.0/#sec-hours-minutes-second-and-milliseconds' + }, + SerializeJSONArray: { + url: 'https://262.ecma-international.org/7.0/#sec-serializejsonarray' + }, + SerializeJSONObject: { + url: 'https://262.ecma-international.org/7.0/#sec-serializejsonobject' + }, + SerializeJSONProperty: { + url: 'https://262.ecma-international.org/7.0/#sec-serializejsonproperty' + }, + Set: { + url: 'https://262.ecma-international.org/7.0/#sec-set-o-p-v-throw' + }, + SetDefaultGlobalBindings: { + url: 'https://262.ecma-international.org/7.0/#sec-setdefaultglobalbindings' + }, + SetFunctionName: { + url: 'https://262.ecma-international.org/7.0/#sec-setfunctionname' + }, + SetIntegrityLevel: { + url: 'https://262.ecma-international.org/7.0/#sec-setintegritylevel' + }, + SetRealmGlobalObject: { + url: 'https://262.ecma-international.org/7.0/#sec-setrealmglobalobject' + }, + SetValueInBuffer: { + url: 'https://262.ecma-international.org/7.0/#sec-setvalueinbuffer' + }, + SetViewValue: { + url: 'https://262.ecma-international.org/7.0/#sec-setviewvalue' + }, + SortCompare: { + url: 'https://262.ecma-international.org/7.0/#sec-sortcompare' + }, + SpeciesConstructor: { + url: 'https://262.ecma-international.org/7.0/#sec-speciesconstructor' + }, + SplitMatch: { + url: 'https://262.ecma-international.org/7.0/#sec-splitmatch' + }, + 'Strict Equality Comparison': { + url: 'https://262.ecma-international.org/7.0/#sec-strict-equality-comparison' + }, + StringCreate: { + url: 'https://262.ecma-international.org/7.0/#sec-stringcreate' + }, + SymbolDescriptiveString: { + url: 'https://262.ecma-international.org/7.0/#sec-symboldescriptivestring' + }, + TestIntegrityLevel: { + url: 'https://262.ecma-international.org/7.0/#sec-testintegritylevel' + }, + thisBooleanValue: { + url: 'https://262.ecma-international.org/7.0/#sec-thisbooleanvalue' + }, + thisNumberValue: { + url: 'https://262.ecma-international.org/7.0/#sec-properties-of-the-number-prototype-object' + }, + thisStringValue: { + url: 'https://262.ecma-international.org/7.0/#sec-properties-of-the-string-prototype-object' + }, + thisTimeValue: { + url: 'https://262.ecma-international.org/7.0/#sec-properties-of-the-date-prototype-object' + }, + TimeClip: { + url: 'https://262.ecma-international.org/7.0/#sec-timeclip' + }, + TimeFromYear: { + url: 'https://262.ecma-international.org/7.0/#sec-year-number' + }, + TimeWithinDay: { + url: 'https://262.ecma-international.org/7.0/#sec-day-number-and-time-within-day' + }, + ToBoolean: { + url: 'https://262.ecma-international.org/7.0/#sec-toboolean' + }, + ToDateString: { + url: 'https://262.ecma-international.org/7.0/#sec-todatestring' + }, + ToInt16: { + url: 'https://262.ecma-international.org/7.0/#sec-toint16' + }, + ToInt32: { + url: 'https://262.ecma-international.org/7.0/#sec-toint32' + }, + ToInt8: { + url: 'https://262.ecma-international.org/7.0/#sec-toint8' + }, + ToInteger: { + url: 'https://262.ecma-international.org/7.0/#sec-tointeger' + }, + ToLength: { + url: 'https://262.ecma-international.org/7.0/#sec-tolength' + }, + ToNumber: { + url: 'https://262.ecma-international.org/7.0/#sec-tonumber' + }, + ToObject: { + url: 'https://262.ecma-international.org/7.0/#sec-toobject' + }, + TopLevelModuleEvaluationJob: { + url: 'https://262.ecma-international.org/7.0/#sec-toplevelmoduleevaluationjob' + }, + ToPrimitive: { + url: 'https://262.ecma-international.org/7.0/#sec-toprimitive' + }, + ToPropertyDescriptor: { + url: 'https://262.ecma-international.org/7.0/#sec-topropertydescriptor' + }, + ToPropertyKey: { + url: 'https://262.ecma-international.org/7.0/#sec-topropertykey' + }, + ToString: { + url: 'https://262.ecma-international.org/7.0/#sec-tostring' + }, + 'ToString Applied to the Number Type': { + url: 'https://262.ecma-international.org/7.0/#sec-tostring-applied-to-the-number-type' + }, + ToUint16: { + url: 'https://262.ecma-international.org/7.0/#sec-touint16' + }, + ToUint32: { + url: 'https://262.ecma-international.org/7.0/#sec-touint32' + }, + ToUint8: { + url: 'https://262.ecma-international.org/7.0/#sec-touint8' + }, + ToUint8Clamp: { + url: 'https://262.ecma-international.org/7.0/#sec-touint8clamp' + }, + TriggerPromiseReactions: { + url: 'https://262.ecma-international.org/7.0/#sec-triggerpromisereactions' + }, + Type: { + url: 'https://262.ecma-international.org/7.0/#sec-ecmascript-data-types-and-values' + }, + TypedArrayCreate: { + url: 'https://262.ecma-international.org/7.0/#typedarray-create' + }, + TypedArraySpeciesCreate: { + url: 'https://262.ecma-international.org/7.0/#typedarray-species-create' + }, + UpdateEmpty: { + url: 'https://262.ecma-international.org/7.0/#sec-updateempty' + }, + UTC: { + url: 'https://262.ecma-international.org/7.0/#sec-utc-t' + }, + UTF16Decode: { + url: 'https://262.ecma-international.org/7.0/#sec-utf16decode' + }, + UTF16Encoding: { + url: 'https://262.ecma-international.org/7.0/#sec-utf16encoding' + }, + ValidateAndApplyPropertyDescriptor: { + url: 'https://262.ecma-international.org/7.0/#sec-validateandapplypropertydescriptor' + }, + ValidateTypedArray: { + url: 'https://262.ecma-international.org/7.0/#sec-validatetypedarray' + }, + WeekDay: { + url: 'https://262.ecma-international.org/7.0/#sec-week-day' + }, + YearFromTime: { + url: 'https://262.ecma-international.org/7.0/#sec-year-number' + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2017.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2017.js new file mode 100644 index 0000000000000000000000000000000000000000..5fa6e6aeafdbef80e13dfb70414ab54b56b43868 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2017.js @@ -0,0 +1,954 @@ +'use strict'; + +module.exports = { + IsPropertyDescriptor: 'https://262.ecma-international.org/6.0/#sec-property-descriptor-specification-type', // not actually an abstract op + + abs: { + url: 'https://262.ecma-international.org/8.0/#eqn-abs' + }, + 'Abstract Equality Comparison': { + url: 'https://262.ecma-international.org/8.0/#sec-abstract-equality-comparison' + }, + 'Abstract Relational Comparison': { + url: 'https://262.ecma-international.org/8.0/#sec-abstract-relational-comparison' + }, + AddRestrictedFunctionProperties: { + url: 'https://262.ecma-international.org/8.0/#sec-addrestrictedfunctionproperties' + }, + AddWaiter: { + url: 'https://262.ecma-international.org/8.0/#sec-addwaiter' + }, + AdvanceStringIndex: { + url: 'https://262.ecma-international.org/8.0/#sec-advancestringindex' + }, + 'agent-order': { + url: 'https://262.ecma-international.org/8.0/#sec-agent-order' + }, + AgentCanSuspend: { + url: 'https://262.ecma-international.org/8.0/#sec-agentcansuspend' + }, + AgentSignifier: { + url: 'https://262.ecma-international.org/8.0/#sec-agentsignifier' + }, + AllocateArrayBuffer: { + url: 'https://262.ecma-international.org/8.0/#sec-allocatearraybuffer' + }, + AllocateSharedArrayBuffer: { + url: 'https://262.ecma-international.org/8.0/#sec-allocatesharedarraybuffer' + }, + AllocateTypedArray: { + url: 'https://262.ecma-international.org/8.0/#sec-allocatetypedarray' + }, + AllocateTypedArrayBuffer: { + url: 'https://262.ecma-international.org/8.0/#sec-allocatetypedarraybuffer' + }, + ArrayCreate: { + url: 'https://262.ecma-international.org/8.0/#sec-arraycreate' + }, + ArraySetLength: { + url: 'https://262.ecma-international.org/8.0/#sec-arraysetlength' + }, + ArraySpeciesCreate: { + url: 'https://262.ecma-international.org/8.0/#sec-arrayspeciescreate' + }, + AsyncFunctionAwait: { + url: 'https://262.ecma-international.org/8.0/#sec-async-functions-abstract-operations-async-function-await' + }, + AsyncFunctionCreate: { + url: 'https://262.ecma-international.org/8.0/#sec-async-functions-abstract-operations-async-function-create' + }, + AsyncFunctionStart: { + url: 'https://262.ecma-international.org/8.0/#sec-async-functions-abstract-operations-async-function-start' + }, + AtomicLoad: { + url: 'https://262.ecma-international.org/8.0/#sec-atomicload' + }, + AtomicReadModifyWrite: { + url: 'https://262.ecma-international.org/8.0/#sec-atomicreadmodifywrite' + }, + BlockDeclarationInstantiation: { + url: 'https://262.ecma-international.org/8.0/#sec-blockdeclarationinstantiation' + }, + BoundFunctionCreate: { + url: 'https://262.ecma-international.org/8.0/#sec-boundfunctioncreate' + }, + Call: { + url: 'https://262.ecma-international.org/8.0/#sec-call' + }, + Canonicalize: { + url: 'https://262.ecma-international.org/8.0/#sec-runtime-semantics-canonicalize-ch' + }, + CanonicalNumericIndexString: { + url: 'https://262.ecma-international.org/8.0/#sec-canonicalnumericindexstring' + }, + CharacterRange: { + url: 'https://262.ecma-international.org/8.0/#sec-runtime-semantics-characterrange-abstract-operation' + }, + CharacterRangeOrUnion: { + url: 'https://262.ecma-international.org/8.0/#sec-runtime-semantics-characterrangeorunion-abstract-operation' + }, + CharacterSetMatcher: { + url: 'https://262.ecma-international.org/8.0/#sec-runtime-semantics-charactersetmatcher-abstract-operation' + }, + CloneArrayBuffer: { + url: 'https://262.ecma-international.org/8.0/#sec-clonearraybuffer' + }, + CompletePropertyDescriptor: { + url: 'https://262.ecma-international.org/8.0/#sec-completepropertydescriptor' + }, + Completion: { + url: 'https://262.ecma-international.org/8.0/#sec-completion-record-specification-type' + }, + CompletionRecord: { + url: 'https://262.ecma-international.org/8.0/#sec-completion-record-specification-type' + }, + ComposeWriteEventBytes: { + url: 'https://262.ecma-international.org/8.0/#sec-composewriteeventbytes' + }, + Construct: { + url: 'https://262.ecma-international.org/8.0/#sec-construct' + }, + CopyDataBlockBytes: { + url: 'https://262.ecma-international.org/8.0/#sec-copydatablockbytes' + }, + CreateArrayFromList: { + url: 'https://262.ecma-international.org/8.0/#sec-createarrayfromlist' + }, + CreateArrayIterator: { + url: 'https://262.ecma-international.org/8.0/#sec-createarrayiterator' + }, + CreateBuiltinFunction: { + url: 'https://262.ecma-international.org/8.0/#sec-createbuiltinfunction' + }, + CreateByteDataBlock: { + url: 'https://262.ecma-international.org/8.0/#sec-createbytedatablock' + }, + CreateDataProperty: { + url: 'https://262.ecma-international.org/8.0/#sec-createdataproperty' + }, + CreateDataPropertyOrThrow: { + url: 'https://262.ecma-international.org/8.0/#sec-createdatapropertyorthrow' + }, + CreateDynamicFunction: { + url: 'https://262.ecma-international.org/8.0/#sec-createdynamicfunction' + }, + CreateHTML: { + url: 'https://262.ecma-international.org/8.0/#sec-createhtml' + }, + CreateIntrinsics: { + url: 'https://262.ecma-international.org/8.0/#sec-createintrinsics' + }, + CreateIterResultObject: { + url: 'https://262.ecma-international.org/8.0/#sec-createiterresultobject' + }, + CreateListFromArrayLike: { + url: 'https://262.ecma-international.org/8.0/#sec-createlistfromarraylike' + }, + CreateListIterator: { + url: 'https://262.ecma-international.org/8.0/#sec-createlistiterator' + }, + CreateMapIterator: { + url: 'https://262.ecma-international.org/8.0/#sec-createmapiterator' + }, + CreateMappedArgumentsObject: { + url: 'https://262.ecma-international.org/8.0/#sec-createmappedargumentsobject' + }, + CreateMethodProperty: { + url: 'https://262.ecma-international.org/8.0/#sec-createmethodproperty' + }, + CreatePerIterationEnvironment: { + url: 'https://262.ecma-international.org/8.0/#sec-createperiterationenvironment' + }, + CreateRealm: { + url: 'https://262.ecma-international.org/8.0/#sec-createrealm' + }, + CreateResolvingFunctions: { + url: 'https://262.ecma-international.org/8.0/#sec-createresolvingfunctions' + }, + CreateSetIterator: { + url: 'https://262.ecma-international.org/8.0/#sec-createsetiterator' + }, + CreateSharedByteDataBlock: { + url: 'https://262.ecma-international.org/8.0/#sec-createsharedbytedatablock' + }, + CreateStringIterator: { + url: 'https://262.ecma-international.org/8.0/#sec-createstringiterator' + }, + CreateUnmappedArgumentsObject: { + url: 'https://262.ecma-international.org/8.0/#sec-createunmappedargumentsobject' + }, + DateFromTime: { + url: 'https://262.ecma-international.org/8.0/#sec-date-number' + }, + Day: { + url: 'https://262.ecma-international.org/8.0/#eqn-Day' + }, + DayFromYear: { + url: 'https://262.ecma-international.org/8.0/#eqn-DaysFromYear' + }, + DaylightSavingTA: { + url: 'https://262.ecma-international.org/8.0/#sec-daylight-saving-time-adjustment' + }, + DaysInYear: { + url: 'https://262.ecma-international.org/8.0/#eqn-DaysInYear' + }, + DayWithinYear: { + url: 'https://262.ecma-international.org/8.0/#eqn-DayWithinYear' + }, + Decode: { + url: 'https://262.ecma-international.org/8.0/#sec-decode' + }, + DefinePropertyOrThrow: { + url: 'https://262.ecma-international.org/8.0/#sec-definepropertyorthrow' + }, + DeletePropertyOrThrow: { + url: 'https://262.ecma-international.org/8.0/#sec-deletepropertyorthrow' + }, + DetachArrayBuffer: { + url: 'https://262.ecma-international.org/8.0/#sec-detacharraybuffer' + }, + Encode: { + url: 'https://262.ecma-international.org/8.0/#sec-encode' + }, + EnqueueJob: { + url: 'https://262.ecma-international.org/8.0/#sec-enqueuejob' + }, + EnterCriticalSection: { + url: 'https://262.ecma-international.org/8.0/#sec-entercriticalsection' + }, + EnumerableOwnProperties: { + url: 'https://262.ecma-international.org/8.0/#sec-enumerableownproperties' + }, + EnumerateObjectProperties: { + url: 'https://262.ecma-international.org/8.0/#sec-enumerate-object-properties' + }, + EscapeRegExpPattern: { + url: 'https://262.ecma-international.org/8.0/#sec-escaperegexppattern' + }, + EvalDeclarationInstantiation: { + url: 'https://262.ecma-international.org/8.0/#sec-evaldeclarationinstantiation' + }, + EvaluateCall: { + url: 'https://262.ecma-international.org/8.0/#sec-evaluatecall' + }, + EvaluateDirectCall: { + url: 'https://262.ecma-international.org/8.0/#sec-evaluatedirectcall' + }, + EvaluateNew: { + url: 'https://262.ecma-international.org/8.0/#sec-evaluatenew' + }, + EventSet: { + url: 'https://262.ecma-international.org/8.0/#sec-event-set' + }, + floor: { + url: 'https://262.ecma-international.org/8.0/#eqn-floor' + }, + ForBodyEvaluation: { + url: 'https://262.ecma-international.org/8.0/#sec-forbodyevaluation' + }, + 'ForIn/OfBodyEvaluation': { + url: 'https://262.ecma-international.org/8.0/#sec-runtime-semantics-forin-div-ofbodyevaluation-lhs-stmt-iterator-lhskind-labelset' + }, + 'ForIn/OfHeadEvaluation': { + url: 'https://262.ecma-international.org/8.0/#sec-runtime-semantics-forin-div-ofheadevaluation-tdznames-expr-iterationkind' + }, + FromPropertyDescriptor: { + url: 'https://262.ecma-international.org/8.0/#sec-frompropertydescriptor' + }, + FulfillPromise: { + url: 'https://262.ecma-international.org/8.0/#sec-fulfillpromise' + }, + FunctionAllocate: { + url: 'https://262.ecma-international.org/8.0/#sec-functionallocate' + }, + FunctionCreate: { + url: 'https://262.ecma-international.org/8.0/#sec-functioncreate' + }, + FunctionDeclarationInstantiation: { + url: 'https://262.ecma-international.org/8.0/#sec-functiondeclarationinstantiation' + }, + FunctionInitialize: { + url: 'https://262.ecma-international.org/8.0/#sec-functioninitialize' + }, + GeneratorFunctionCreate: { + url: 'https://262.ecma-international.org/8.0/#sec-generatorfunctioncreate' + }, + GeneratorResume: { + url: 'https://262.ecma-international.org/8.0/#sec-generatorresume' + }, + GeneratorResumeAbrupt: { + url: 'https://262.ecma-international.org/8.0/#sec-generatorresumeabrupt' + }, + GeneratorStart: { + url: 'https://262.ecma-international.org/8.0/#sec-generatorstart' + }, + GeneratorValidate: { + url: 'https://262.ecma-international.org/8.0/#sec-generatorvalidate' + }, + GeneratorYield: { + url: 'https://262.ecma-international.org/8.0/#sec-generatoryield' + }, + Get: { + url: 'https://262.ecma-international.org/8.0/#sec-get-o-p' + }, + GetActiveScriptOrModule: { + url: 'https://262.ecma-international.org/8.0/#sec-getactivescriptormodule' + }, + GetBase: { + url: 'https://262.ecma-international.org/8.0/#ao-getbase' + }, + GetFunctionRealm: { + url: 'https://262.ecma-international.org/8.0/#sec-getfunctionrealm' + }, + GetGlobalObject: { + url: 'https://262.ecma-international.org/8.0/#sec-getglobalobject' + }, + GetIdentifierReference: { + url: 'https://262.ecma-international.org/8.0/#sec-getidentifierreference' + }, + GetIterator: { + url: 'https://262.ecma-international.org/8.0/#sec-getiterator' + }, + GetMethod: { + url: 'https://262.ecma-international.org/8.0/#sec-getmethod' + }, + GetModifySetValueInBuffer: { + url: 'https://262.ecma-international.org/8.0/#sec-getmodifysetvalueinbuffer' + }, + GetModuleNamespace: { + url: 'https://262.ecma-international.org/8.0/#sec-getmodulenamespace' + }, + GetNewTarget: { + url: 'https://262.ecma-international.org/8.0/#sec-getnewtarget' + }, + GetOwnPropertyKeys: { + url: 'https://262.ecma-international.org/8.0/#sec-getownpropertykeys' + }, + GetPrototypeFromConstructor: { + url: 'https://262.ecma-international.org/8.0/#sec-getprototypefromconstructor' + }, + GetReferencedName: { + url: 'https://262.ecma-international.org/8.0/#ao-getreferencedname' + }, + GetSubstitution: { + url: 'https://262.ecma-international.org/8.0/#sec-getsubstitution' + }, + GetSuperConstructor: { + url: 'https://262.ecma-international.org/8.0/#sec-getsuperconstructor' + }, + GetTemplateObject: { + url: 'https://262.ecma-international.org/8.0/#sec-gettemplateobject' + }, + GetThisEnvironment: { + url: 'https://262.ecma-international.org/8.0/#sec-getthisenvironment' + }, + GetThisValue: { + url: 'https://262.ecma-international.org/8.0/#sec-getthisvalue' + }, + GetV: { + url: 'https://262.ecma-international.org/8.0/#sec-getv' + }, + GetValue: { + url: 'https://262.ecma-international.org/8.0/#sec-getvalue' + }, + GetValueFromBuffer: { + url: 'https://262.ecma-international.org/8.0/#sec-getvaluefrombuffer' + }, + GetViewValue: { + url: 'https://262.ecma-international.org/8.0/#sec-getviewvalue' + }, + GetWaiterList: { + url: 'https://262.ecma-international.org/8.0/#sec-getwaiterlist' + }, + GlobalDeclarationInstantiation: { + url: 'https://262.ecma-international.org/8.0/#sec-globaldeclarationinstantiation' + }, + 'happens-before': { + url: 'https://262.ecma-international.org/8.0/#sec-happens-before' + }, + HasOwnProperty: { + url: 'https://262.ecma-international.org/8.0/#sec-hasownproperty' + }, + HasPrimitiveBase: { + url: 'https://262.ecma-international.org/8.0/#ao-hasprimitivebase' + }, + HasProperty: { + url: 'https://262.ecma-international.org/8.0/#sec-hasproperty' + }, + 'host-synchronizes-with': { + url: 'https://262.ecma-international.org/8.0/#sec-host-synchronizes-with' + }, + HostEventSet: { + url: 'https://262.ecma-international.org/8.0/#sec-hosteventset' + }, + HourFromTime: { + url: 'https://262.ecma-international.org/8.0/#eqn-HourFromTime' + }, + IfAbruptRejectPromise: { + url: 'https://262.ecma-international.org/8.0/#sec-ifabruptrejectpromise' + }, + ImportedLocalNames: { + url: 'https://262.ecma-international.org/8.0/#sec-importedlocalnames' + }, + InitializeBoundName: { + url: 'https://262.ecma-international.org/8.0/#sec-initializeboundname' + }, + InitializeHostDefinedRealm: { + url: 'https://262.ecma-international.org/8.0/#sec-initializehostdefinedrealm' + }, + InitializeReferencedBinding: { + url: 'https://262.ecma-international.org/8.0/#sec-initializereferencedbinding' + }, + InLeapYear: { + url: 'https://262.ecma-international.org/8.0/#eqn-InLeapYear' + }, + InstanceofOperator: { + url: 'https://262.ecma-international.org/8.0/#sec-instanceofoperator' + }, + IntegerIndexedElementGet: { + url: 'https://262.ecma-international.org/8.0/#sec-integerindexedelementget' + }, + IntegerIndexedElementSet: { + url: 'https://262.ecma-international.org/8.0/#sec-integerindexedelementset' + }, + IntegerIndexedObjectCreate: { + url: 'https://262.ecma-international.org/8.0/#sec-integerindexedobjectcreate' + }, + InternalizeJSONProperty: { + url: 'https://262.ecma-international.org/8.0/#sec-internalizejsonproperty' + }, + Invoke: { + url: 'https://262.ecma-international.org/8.0/#sec-invoke' + }, + IsAccessorDescriptor: { + url: 'https://262.ecma-international.org/8.0/#sec-isaccessordescriptor' + }, + IsAnonymousFunctionDefinition: { + url: 'https://262.ecma-international.org/8.0/#sec-isanonymousfunctiondefinition' + }, + IsArray: { + url: 'https://262.ecma-international.org/8.0/#sec-isarray' + }, + IsCallable: { + url: 'https://262.ecma-international.org/8.0/#sec-iscallable' + }, + IsCompatiblePropertyDescriptor: { + url: 'https://262.ecma-international.org/8.0/#sec-iscompatiblepropertydescriptor' + }, + IsConcatSpreadable: { + url: 'https://262.ecma-international.org/8.0/#sec-isconcatspreadable' + }, + IsConstructor: { + url: 'https://262.ecma-international.org/8.0/#sec-isconstructor' + }, + IsDataDescriptor: { + url: 'https://262.ecma-international.org/8.0/#sec-isdatadescriptor' + }, + IsDetachedBuffer: { + url: 'https://262.ecma-international.org/8.0/#sec-isdetachedbuffer' + }, + IsExtensible: { + url: 'https://262.ecma-international.org/8.0/#sec-isextensible-o' + }, + IsGenericDescriptor: { + url: 'https://262.ecma-international.org/8.0/#sec-isgenericdescriptor' + }, + IsInTailPosition: { + url: 'https://262.ecma-international.org/8.0/#sec-isintailposition' + }, + IsInteger: { + url: 'https://262.ecma-international.org/8.0/#sec-isinteger' + }, + IsLabelledFunction: { + url: 'https://262.ecma-international.org/8.0/#sec-islabelledfunction' + }, + IsPromise: { + url: 'https://262.ecma-international.org/8.0/#sec-ispromise' + }, + IsPropertyKey: { + url: 'https://262.ecma-international.org/8.0/#sec-ispropertykey' + }, + IsPropertyReference: { + url: 'https://262.ecma-international.org/8.0/#ao-ispropertyreference' + }, + IsRegExp: { + url: 'https://262.ecma-international.org/8.0/#sec-isregexp' + }, + IsSharedArrayBuffer: { + url: 'https://262.ecma-international.org/8.0/#sec-issharedarraybuffer' + }, + IsStrictReference: { + url: 'https://262.ecma-international.org/8.0/#ao-isstrictreference' + }, + IsSuperReference: { + url: 'https://262.ecma-international.org/8.0/#ao-issuperreference' + }, + IsUnresolvableReference: { + url: 'https://262.ecma-international.org/8.0/#ao-isunresolvablereference' + }, + IsWordChar: { + url: 'https://262.ecma-international.org/8.0/#sec-runtime-semantics-iswordchar-abstract-operation' + }, + IterableToList: { + url: 'https://262.ecma-international.org/8.0/#sec-iterabletolist' + }, + IteratorClose: { + url: 'https://262.ecma-international.org/8.0/#sec-iteratorclose' + }, + IteratorComplete: { + url: 'https://262.ecma-international.org/8.0/#sec-iteratorcomplete' + }, + IteratorNext: { + url: 'https://262.ecma-international.org/8.0/#sec-iteratornext' + }, + IteratorStep: { + url: 'https://262.ecma-international.org/8.0/#sec-iteratorstep' + }, + IteratorValue: { + url: 'https://262.ecma-international.org/8.0/#sec-iteratorvalue' + }, + LeaveCriticalSection: { + url: 'https://262.ecma-international.org/8.0/#sec-leavecriticalsection' + }, + LocalTime: { + url: 'https://262.ecma-international.org/8.0/#sec-localtime' + }, + LoopContinues: { + url: 'https://262.ecma-international.org/8.0/#sec-loopcontinues' + }, + MakeArgGetter: { + url: 'https://262.ecma-international.org/8.0/#sec-makearggetter' + }, + MakeArgSetter: { + url: 'https://262.ecma-international.org/8.0/#sec-makeargsetter' + }, + MakeClassConstructor: { + url: 'https://262.ecma-international.org/8.0/#sec-makeclassconstructor' + }, + MakeConstructor: { + url: 'https://262.ecma-international.org/8.0/#sec-makeconstructor' + }, + MakeDate: { + url: 'https://262.ecma-international.org/8.0/#sec-makedate' + }, + MakeDay: { + url: 'https://262.ecma-international.org/8.0/#sec-makeday' + }, + MakeMethod: { + url: 'https://262.ecma-international.org/8.0/#sec-makemethod' + }, + MakeSuperPropertyReference: { + url: 'https://262.ecma-international.org/8.0/#sec-makesuperpropertyreference' + }, + MakeTime: { + url: 'https://262.ecma-international.org/8.0/#sec-maketime' + }, + max: { + url: 'https://262.ecma-international.org/8.0/#eqn-max' + }, + 'memory-order': { + url: 'https://262.ecma-international.org/8.0/#sec-memory-order' + }, + min: { + url: 'https://262.ecma-international.org/8.0/#eqn-min' + }, + MinFromTime: { + url: 'https://262.ecma-international.org/8.0/#eqn-MinFromTime' + }, + ModuleNamespaceCreate: { + url: 'https://262.ecma-international.org/8.0/#sec-modulenamespacecreate' + }, + modulo: { + url: 'https://262.ecma-international.org/8.0/#eqn-modulo' + }, + MonthFromTime: { + url: 'https://262.ecma-international.org/8.0/#eqn-MonthFromTime' + }, + msFromTime: { + url: 'https://262.ecma-international.org/8.0/#eqn-msFromTime' + }, + NewDeclarativeEnvironment: { + url: 'https://262.ecma-international.org/8.0/#sec-newdeclarativeenvironment' + }, + NewFunctionEnvironment: { + url: 'https://262.ecma-international.org/8.0/#sec-newfunctionenvironment' + }, + NewGlobalEnvironment: { + url: 'https://262.ecma-international.org/8.0/#sec-newglobalenvironment' + }, + NewModuleEnvironment: { + url: 'https://262.ecma-international.org/8.0/#sec-newmoduleenvironment' + }, + NewObjectEnvironment: { + url: 'https://262.ecma-international.org/8.0/#sec-newobjectenvironment' + }, + NewPromiseCapability: { + url: 'https://262.ecma-international.org/8.0/#sec-newpromisecapability' + }, + NormalCompletion: { + url: 'https://262.ecma-international.org/8.0/#sec-normalcompletion' + }, + NumberToRawBytes: { + url: 'https://262.ecma-international.org/8.0/#sec-numbertorawbytes' + }, + ObjectCreate: { + url: 'https://262.ecma-international.org/8.0/#sec-objectcreate' + }, + ObjectDefineProperties: { + url: 'https://262.ecma-international.org/8.0/#sec-objectdefineproperties' + }, + OrdinaryCallBindThis: { + url: 'https://262.ecma-international.org/8.0/#sec-ordinarycallbindthis' + }, + OrdinaryCallEvaluateBody: { + url: 'https://262.ecma-international.org/8.0/#sec-ordinarycallevaluatebody' + }, + OrdinaryCreateFromConstructor: { + url: 'https://262.ecma-international.org/8.0/#sec-ordinarycreatefromconstructor' + }, + OrdinaryDefineOwnProperty: { + url: 'https://262.ecma-international.org/8.0/#sec-ordinarydefineownproperty' + }, + OrdinaryDelete: { + url: 'https://262.ecma-international.org/8.0/#sec-ordinarydelete' + }, + OrdinaryGet: { + url: 'https://262.ecma-international.org/8.0/#sec-ordinaryget' + }, + OrdinaryGetOwnProperty: { + url: 'https://262.ecma-international.org/8.0/#sec-ordinarygetownproperty' + }, + OrdinaryGetPrototypeOf: { + url: 'https://262.ecma-international.org/8.0/#sec-ordinarygetprototypeof' + }, + OrdinaryHasInstance: { + url: 'https://262.ecma-international.org/8.0/#sec-ordinaryhasinstance' + }, + OrdinaryHasProperty: { + url: 'https://262.ecma-international.org/8.0/#sec-ordinaryhasproperty' + }, + OrdinaryIsExtensible: { + url: 'https://262.ecma-international.org/8.0/#sec-ordinaryisextensible' + }, + OrdinaryOwnPropertyKeys: { + url: 'https://262.ecma-international.org/8.0/#sec-ordinaryownpropertykeys' + }, + OrdinaryPreventExtensions: { + url: 'https://262.ecma-international.org/8.0/#sec-ordinarypreventextensions' + }, + OrdinarySet: { + url: 'https://262.ecma-international.org/8.0/#sec-ordinaryset' + }, + OrdinarySetPrototypeOf: { + url: 'https://262.ecma-international.org/8.0/#sec-ordinarysetprototypeof' + }, + OrdinaryToPrimitive: { + url: 'https://262.ecma-international.org/8.0/#sec-ordinarytoprimitive' + }, + ParseModule: { + url: 'https://262.ecma-international.org/8.0/#sec-parsemodule' + }, + ParseScript: { + url: 'https://262.ecma-international.org/8.0/#sec-parse-script' + }, + PerformEval: { + url: 'https://262.ecma-international.org/8.0/#sec-performeval' + }, + PerformPromiseAll: { + url: 'https://262.ecma-international.org/8.0/#sec-performpromiseall' + }, + PerformPromiseRace: { + url: 'https://262.ecma-international.org/8.0/#sec-performpromiserace' + }, + PerformPromiseThen: { + url: 'https://262.ecma-international.org/8.0/#sec-performpromisethen' + }, + PrepareForOrdinaryCall: { + url: 'https://262.ecma-international.org/8.0/#sec-prepareforordinarycall' + }, + PrepareForTailCall: { + url: 'https://262.ecma-international.org/8.0/#sec-preparefortailcall' + }, + PromiseReactionJob: { + url: 'https://262.ecma-international.org/8.0/#sec-promisereactionjob' + }, + PromiseResolveThenableJob: { + url: 'https://262.ecma-international.org/8.0/#sec-promiseresolvethenablejob' + }, + ProxyCreate: { + url: 'https://262.ecma-international.org/8.0/#sec-proxycreate' + }, + PutValue: { + url: 'https://262.ecma-international.org/8.0/#sec-putvalue' + }, + QuoteJSONString: { + url: 'https://262.ecma-international.org/8.0/#sec-quotejsonstring' + }, + RawBytesToNumber: { + url: 'https://262.ecma-international.org/8.0/#sec-rawbytestonumber' + }, + 'reads-bytes-from': { + url: 'https://262.ecma-international.org/8.0/#sec-reads-bytes-from' + }, + 'reads-from': { + url: 'https://262.ecma-international.org/8.0/#sec-reads-from' + }, + RegExpAlloc: { + url: 'https://262.ecma-international.org/8.0/#sec-regexpalloc' + }, + RegExpBuiltinExec: { + url: 'https://262.ecma-international.org/8.0/#sec-regexpbuiltinexec' + }, + RegExpCreate: { + url: 'https://262.ecma-international.org/8.0/#sec-regexpcreate' + }, + RegExpExec: { + url: 'https://262.ecma-international.org/8.0/#sec-regexpexec' + }, + RegExpInitialize: { + url: 'https://262.ecma-international.org/8.0/#sec-regexpinitialize' + }, + RejectPromise: { + url: 'https://262.ecma-international.org/8.0/#sec-rejectpromise' + }, + RemoveWaiter: { + url: 'https://262.ecma-international.org/8.0/#sec-removewaiter' + }, + RemoveWaiters: { + url: 'https://262.ecma-international.org/8.0/#sec-removewaiters' + }, + RepeatMatcher: { + url: 'https://262.ecma-international.org/8.0/#sec-runtime-semantics-repeatmatcher-abstract-operation' + }, + RequireObjectCoercible: { + url: 'https://262.ecma-international.org/8.0/#sec-requireobjectcoercible' + }, + ResolveBinding: { + url: 'https://262.ecma-international.org/8.0/#sec-resolvebinding' + }, + ResolveThisBinding: { + url: 'https://262.ecma-international.org/8.0/#sec-resolvethisbinding' + }, + ReturnIfAbrupt: { + url: 'https://262.ecma-international.org/8.0/#sec-returnifabrupt' + }, + RunJobs: { + url: 'https://262.ecma-international.org/8.0/#sec-runjobs' + }, + SameValue: { + url: 'https://262.ecma-international.org/8.0/#sec-samevalue' + }, + SameValueNonNumber: { + url: 'https://262.ecma-international.org/8.0/#sec-samevaluenonnumber' + }, + SameValueZero: { + url: 'https://262.ecma-international.org/8.0/#sec-samevaluezero' + }, + ScriptEvaluation: { + url: 'https://262.ecma-international.org/8.0/#sec-runtime-semantics-scriptevaluation' + }, + ScriptEvaluationJob: { + url: 'https://262.ecma-international.org/8.0/#sec-scriptevaluationjob' + }, + SecFromTime: { + url: 'https://262.ecma-international.org/8.0/#eqn-SecFromTime' + }, + SerializeJSONArray: { + url: 'https://262.ecma-international.org/8.0/#sec-serializejsonarray' + }, + SerializeJSONObject: { + url: 'https://262.ecma-international.org/8.0/#sec-serializejsonobject' + }, + SerializeJSONProperty: { + url: 'https://262.ecma-international.org/8.0/#sec-serializejsonproperty' + }, + Set: { + url: 'https://262.ecma-international.org/8.0/#sec-set-o-p-v-throw' + }, + SetDefaultGlobalBindings: { + url: 'https://262.ecma-international.org/8.0/#sec-setdefaultglobalbindings' + }, + SetFunctionName: { + url: 'https://262.ecma-international.org/8.0/#sec-setfunctionname' + }, + SetImmutablePrototype: { + url: 'https://262.ecma-international.org/8.0/#sec-set-immutable-prototype' + }, + SetIntegrityLevel: { + url: 'https://262.ecma-international.org/8.0/#sec-setintegritylevel' + }, + SetRealmGlobalObject: { + url: 'https://262.ecma-international.org/8.0/#sec-setrealmglobalobject' + }, + SetValueInBuffer: { + url: 'https://262.ecma-international.org/8.0/#sec-setvalueinbuffer' + }, + SetViewValue: { + url: 'https://262.ecma-international.org/8.0/#sec-setviewvalue' + }, + SharedDataBlockEventSet: { + url: 'https://262.ecma-international.org/8.0/#sec-sharedatablockeventset' + }, + SortCompare: { + url: 'https://262.ecma-international.org/8.0/#sec-sortcompare' + }, + SpeciesConstructor: { + url: 'https://262.ecma-international.org/8.0/#sec-speciesconstructor' + }, + SplitMatch: { + url: 'https://262.ecma-international.org/8.0/#sec-splitmatch' + }, + 'Strict Equality Comparison': { + url: 'https://262.ecma-international.org/8.0/#sec-strict-equality-comparison' + }, + StringCreate: { + url: 'https://262.ecma-international.org/8.0/#sec-stringcreate' + }, + StringGetOwnProperty: { + url: 'https://262.ecma-international.org/8.0/#sec-stringgetownproperty' + }, + Suspend: { + url: 'https://262.ecma-international.org/8.0/#sec-suspend' + }, + SymbolDescriptiveString: { + url: 'https://262.ecma-international.org/8.0/#sec-symboldescriptivestring' + }, + 'synchronizes-with': { + url: 'https://262.ecma-international.org/8.0/#sec-synchronizes-with' + }, + TestIntegrityLevel: { + url: 'https://262.ecma-international.org/8.0/#sec-testintegritylevel' + }, + thisBooleanValue: { + url: 'https://262.ecma-international.org/8.0/#sec-thisbooleanvalue' + }, + thisNumberValue: { + url: 'https://262.ecma-international.org/8.0/#sec-thisnumbervalue' + }, + thisStringValue: { + url: 'https://262.ecma-international.org/8.0/#sec-thisstringvalue' + }, + thisTimeValue: { + url: 'https://262.ecma-international.org/8.0/#sec-thistimevalue' + }, + TimeClip: { + url: 'https://262.ecma-international.org/8.0/#sec-timeclip' + }, + TimeFromYear: { + url: 'https://262.ecma-international.org/8.0/#eqn-TimeFromYear' + }, + TimeWithinDay: { + url: 'https://262.ecma-international.org/8.0/#eqn-TimeWithinDay' + }, + ToBoolean: { + url: 'https://262.ecma-international.org/8.0/#sec-toboolean' + }, + ToDateString: { + url: 'https://262.ecma-international.org/8.0/#sec-todatestring' + }, + ToIndex: { + url: 'https://262.ecma-international.org/8.0/#sec-toindex' + }, + ToInt16: { + url: 'https://262.ecma-international.org/8.0/#sec-toint16' + }, + ToInt32: { + url: 'https://262.ecma-international.org/8.0/#sec-toint32' + }, + ToInt8: { + url: 'https://262.ecma-international.org/8.0/#sec-toint8' + }, + ToInteger: { + url: 'https://262.ecma-international.org/8.0/#sec-tointeger' + }, + ToLength: { + url: 'https://262.ecma-international.org/8.0/#sec-tolength' + }, + ToNumber: { + url: 'https://262.ecma-international.org/8.0/#sec-tonumber' + }, + ToObject: { + url: 'https://262.ecma-international.org/8.0/#sec-toobject' + }, + TopLevelModuleEvaluationJob: { + url: 'https://262.ecma-international.org/8.0/#sec-toplevelmoduleevaluationjob' + }, + ToPrimitive: { + url: 'https://262.ecma-international.org/8.0/#sec-toprimitive' + }, + ToPropertyDescriptor: { + url: 'https://262.ecma-international.org/8.0/#sec-topropertydescriptor' + }, + ToPropertyKey: { + url: 'https://262.ecma-international.org/8.0/#sec-topropertykey' + }, + ToString: { + url: 'https://262.ecma-international.org/8.0/#sec-tostring' + }, + 'ToString Applied to the Number Type': { + url: 'https://262.ecma-international.org/8.0/#sec-tostring-applied-to-the-number-type' + }, + ToUint16: { + url: 'https://262.ecma-international.org/8.0/#sec-touint16' + }, + ToUint32: { + url: 'https://262.ecma-international.org/8.0/#sec-touint32' + }, + ToUint8: { + url: 'https://262.ecma-international.org/8.0/#sec-touint8' + }, + ToUint8Clamp: { + url: 'https://262.ecma-international.org/8.0/#sec-touint8clamp' + }, + TriggerPromiseReactions: { + url: 'https://262.ecma-international.org/8.0/#sec-triggerpromisereactions' + }, + Type: { + url: 'https://262.ecma-international.org/8.0/#sec-ecmascript-data-types-and-values' + }, + TypedArrayCreate: { + url: 'https://262.ecma-international.org/8.0/#typedarray-create' + }, + TypedArraySpeciesCreate: { + url: 'https://262.ecma-international.org/8.0/#typedarray-species-create' + }, + UpdateEmpty: { + url: 'https://262.ecma-international.org/8.0/#sec-updateempty' + }, + UTC: { + url: 'https://262.ecma-international.org/8.0/#sec-utc-t' + }, + UTF16Decode: { + url: 'https://262.ecma-international.org/8.0/#sec-utf16decode' + }, + UTF16Encoding: { + url: 'https://262.ecma-international.org/8.0/#sec-utf16encoding' + }, + ValidateAndApplyPropertyDescriptor: { + url: 'https://262.ecma-international.org/8.0/#sec-validateandapplypropertydescriptor' + }, + ValidateAtomicAccess: { + url: 'https://262.ecma-international.org/8.0/#sec-validateatomicaccess' + }, + ValidateSharedIntegerTypedArray: { + url: 'https://262.ecma-international.org/8.0/#sec-validatesharedintegertypedarray' + }, + ValidateTypedArray: { + url: 'https://262.ecma-international.org/8.0/#sec-validatetypedarray' + }, + ValueOfReadEvent: { + url: 'https://262.ecma-international.org/8.0/#sec-valueofreadevent' + }, + WakeWaiter: { + url: 'https://262.ecma-international.org/8.0/#sec-wakewaiter' + }, + WeekDay: { + url: 'https://262.ecma-international.org/8.0/#sec-week-day' + }, + WordCharacters: { + url: 'https://262.ecma-international.org/8.0/#sec-runtime-semantics-wordcharacters-abstract-operation' + }, + YearFromTime: { + url: 'https://262.ecma-international.org/8.0/#eqn-YearFromTime' + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2018.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2018.js new file mode 100644 index 0000000000000000000000000000000000000000..251a409205fa4286f09e862442f2c837c694cf8d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2018.js @@ -0,0 +1,1033 @@ +'use strict'; + +module.exports = { + abs: { + url: 'https://262.ecma-international.org/9.0/#eqn-abs' + }, + 'Abstract Equality Comparison': { + url: 'https://262.ecma-international.org/9.0/#sec-abstract-equality-comparison' + }, + 'Abstract Relational Comparison': { + url: 'https://262.ecma-international.org/9.0/#sec-abstract-relational-comparison' + }, + AddRestrictedFunctionProperties: { + url: 'https://262.ecma-international.org/9.0/#sec-addrestrictedfunctionproperties' + }, + AddWaiter: { + url: 'https://262.ecma-international.org/9.0/#sec-addwaiter' + }, + AdvanceStringIndex: { + url: 'https://262.ecma-international.org/9.0/#sec-advancestringindex' + }, + 'agent-order': { + url: 'https://262.ecma-international.org/9.0/#sec-agent-order' + }, + AgentCanSuspend: { + url: 'https://262.ecma-international.org/9.0/#sec-agentcansuspend' + }, + AgentSignifier: { + url: 'https://262.ecma-international.org/9.0/#sec-agentsignifier' + }, + AllocateArrayBuffer: { + url: 'https://262.ecma-international.org/9.0/#sec-allocatearraybuffer' + }, + AllocateSharedArrayBuffer: { + url: 'https://262.ecma-international.org/9.0/#sec-allocatesharedarraybuffer' + }, + AllocateTypedArray: { + url: 'https://262.ecma-international.org/9.0/#sec-allocatetypedarray' + }, + AllocateTypedArrayBuffer: { + url: 'https://262.ecma-international.org/9.0/#sec-allocatetypedarraybuffer' + }, + ArrayCreate: { + url: 'https://262.ecma-international.org/9.0/#sec-arraycreate' + }, + ArraySetLength: { + url: 'https://262.ecma-international.org/9.0/#sec-arraysetlength' + }, + ArraySpeciesCreate: { + url: 'https://262.ecma-international.org/9.0/#sec-arrayspeciescreate' + }, + AsyncFunctionCreate: { + url: 'https://262.ecma-international.org/9.0/#sec-async-functions-abstract-operations-async-function-create' + }, + AsyncFunctionStart: { + url: 'https://262.ecma-international.org/9.0/#sec-async-functions-abstract-operations-async-function-start' + }, + AsyncGeneratorEnqueue: { + url: 'https://262.ecma-international.org/9.0/#sec-asyncgeneratorenqueue' + }, + AsyncGeneratorFunctionCreate: { + url: 'https://262.ecma-international.org/9.0/#sec-asyncgeneratorfunctioncreate' + }, + AsyncGeneratorReject: { + url: 'https://262.ecma-international.org/9.0/#sec-asyncgeneratorreject' + }, + AsyncGeneratorResolve: { + url: 'https://262.ecma-international.org/9.0/#sec-asyncgeneratorresolve' + }, + AsyncGeneratorResumeNext: { + url: 'https://262.ecma-international.org/9.0/#sec-asyncgeneratorresumenext' + }, + AsyncGeneratorStart: { + url: 'https://262.ecma-international.org/9.0/#sec-asyncgeneratorstart' + }, + AsyncGeneratorYield: { + url: 'https://262.ecma-international.org/9.0/#sec-asyncgeneratoryield' + }, + AsyncIteratorClose: { + url: 'https://262.ecma-international.org/9.0/#sec-asynciteratorclose' + }, + AtomicLoad: { + url: 'https://262.ecma-international.org/9.0/#sec-atomicload' + }, + AtomicReadModifyWrite: { + url: 'https://262.ecma-international.org/9.0/#sec-atomicreadmodifywrite' + }, + Await: { + url: 'https://262.ecma-international.org/9.0/#await' + }, + BackreferenceMatcher: { + url: 'https://262.ecma-international.org/9.0/#sec-backreference-matcher' + }, + BlockDeclarationInstantiation: { + url: 'https://262.ecma-international.org/9.0/#sec-blockdeclarationinstantiation' + }, + BoundFunctionCreate: { + url: 'https://262.ecma-international.org/9.0/#sec-boundfunctioncreate' + }, + Call: { + url: 'https://262.ecma-international.org/9.0/#sec-call' + }, + Canonicalize: { + url: 'https://262.ecma-international.org/9.0/#sec-runtime-semantics-canonicalize-ch' + }, + CanonicalNumericIndexString: { + url: 'https://262.ecma-international.org/9.0/#sec-canonicalnumericindexstring' + }, + CaseClauseIsSelected: { + url: 'https://262.ecma-international.org/9.0/#sec-runtime-semantics-caseclauseisselected' + }, + CharacterRange: { + url: 'https://262.ecma-international.org/9.0/#sec-runtime-semantics-characterrange-abstract-operation' + }, + CharacterRangeOrUnion: { + url: 'https://262.ecma-international.org/9.0/#sec-runtime-semantics-characterrangeorunion-abstract-operation' + }, + CharacterSetMatcher: { + url: 'https://262.ecma-international.org/9.0/#sec-runtime-semantics-charactersetmatcher-abstract-operation' + }, + CloneArrayBuffer: { + url: 'https://262.ecma-international.org/9.0/#sec-clonearraybuffer' + }, + CompletePropertyDescriptor: { + url: 'https://262.ecma-international.org/9.0/#sec-completepropertydescriptor' + }, + Completion: { + url: 'https://262.ecma-international.org/9.0/#sec-completion-record-specification-type' + }, + CompletionRecord: { + url: 'https://262.ecma-international.org/9.0/#sec-completion-record-specification-type' + }, + ComposeWriteEventBytes: { + url: 'https://262.ecma-international.org/9.0/#sec-composewriteeventbytes' + }, + Construct: { + url: 'https://262.ecma-international.org/9.0/#sec-construct' + }, + CopyDataBlockBytes: { + url: 'https://262.ecma-international.org/9.0/#sec-copydatablockbytes' + }, + CopyDataProperties: { + url: 'https://262.ecma-international.org/9.0/#sec-copydataproperties' + }, + CreateArrayFromList: { + url: 'https://262.ecma-international.org/9.0/#sec-createarrayfromlist' + }, + CreateArrayIterator: { + url: 'https://262.ecma-international.org/9.0/#sec-createarrayiterator' + }, + CreateAsyncFromSyncIterator: { + url: 'https://262.ecma-international.org/9.0/#sec-createasyncfromsynciterator' + }, + CreateBuiltinFunction: { + url: 'https://262.ecma-international.org/9.0/#sec-createbuiltinfunction' + }, + CreateByteDataBlock: { + url: 'https://262.ecma-international.org/9.0/#sec-createbytedatablock' + }, + CreateDataProperty: { + url: 'https://262.ecma-international.org/9.0/#sec-createdataproperty' + }, + CreateDataPropertyOrThrow: { + url: 'https://262.ecma-international.org/9.0/#sec-createdatapropertyorthrow' + }, + CreateDynamicFunction: { + url: 'https://262.ecma-international.org/9.0/#sec-createdynamicfunction' + }, + CreateHTML: { + url: 'https://262.ecma-international.org/9.0/#sec-createhtml' + }, + CreateIntrinsics: { + url: 'https://262.ecma-international.org/9.0/#sec-createintrinsics' + }, + CreateIterResultObject: { + url: 'https://262.ecma-international.org/9.0/#sec-createiterresultobject' + }, + CreateListFromArrayLike: { + url: 'https://262.ecma-international.org/9.0/#sec-createlistfromarraylike' + }, + CreateListIteratorRecord: { + url: 'https://262.ecma-international.org/9.0/#sec-createlistiteratorRecord' + }, + CreateMapIterator: { + url: 'https://262.ecma-international.org/9.0/#sec-createmapiterator' + }, + CreateMappedArgumentsObject: { + url: 'https://262.ecma-international.org/9.0/#sec-createmappedargumentsobject' + }, + CreateMethodProperty: { + url: 'https://262.ecma-international.org/9.0/#sec-createmethodproperty' + }, + CreatePerIterationEnvironment: { + url: 'https://262.ecma-international.org/9.0/#sec-createperiterationenvironment' + }, + CreateRealm: { + url: 'https://262.ecma-international.org/9.0/#sec-createrealm' + }, + CreateResolvingFunctions: { + url: 'https://262.ecma-international.org/9.0/#sec-createresolvingfunctions' + }, + CreateSetIterator: { + url: 'https://262.ecma-international.org/9.0/#sec-createsetiterator' + }, + CreateSharedByteDataBlock: { + url: 'https://262.ecma-international.org/9.0/#sec-createsharedbytedatablock' + }, + CreateStringIterator: { + url: 'https://262.ecma-international.org/9.0/#sec-createstringiterator' + }, + CreateUnmappedArgumentsObject: { + url: 'https://262.ecma-international.org/9.0/#sec-createunmappedargumentsobject' + }, + DateFromTime: { + url: 'https://262.ecma-international.org/9.0/#sec-date-number' + }, + DateString: { + url: 'https://262.ecma-international.org/9.0/#sec-datestring' + }, + Day: { + url: 'https://262.ecma-international.org/9.0/#eqn-Day' + }, + DayFromYear: { + url: 'https://262.ecma-international.org/9.0/#eqn-DaysFromYear' + }, + DaysInYear: { + url: 'https://262.ecma-international.org/9.0/#eqn-DaysInYear' + }, + DayWithinYear: { + url: 'https://262.ecma-international.org/9.0/#eqn-DayWithinYear' + }, + Decode: { + url: 'https://262.ecma-international.org/9.0/#sec-decode' + }, + DefinePropertyOrThrow: { + url: 'https://262.ecma-international.org/9.0/#sec-definepropertyorthrow' + }, + DeletePropertyOrThrow: { + url: 'https://262.ecma-international.org/9.0/#sec-deletepropertyorthrow' + }, + DetachArrayBuffer: { + url: 'https://262.ecma-international.org/9.0/#sec-detacharraybuffer' + }, + Encode: { + url: 'https://262.ecma-international.org/9.0/#sec-encode' + }, + EnqueueJob: { + url: 'https://262.ecma-international.org/9.0/#sec-enqueuejob' + }, + EnterCriticalSection: { + url: 'https://262.ecma-international.org/9.0/#sec-entercriticalsection' + }, + EnumerableOwnPropertyNames: { + url: 'https://262.ecma-international.org/9.0/#sec-enumerableownpropertynames' + }, + EnumerateObjectProperties: { + url: 'https://262.ecma-international.org/9.0/#sec-enumerate-object-properties' + }, + EscapeRegExpPattern: { + url: 'https://262.ecma-international.org/9.0/#sec-escaperegexppattern' + }, + EvalDeclarationInstantiation: { + url: 'https://262.ecma-international.org/9.0/#sec-evaldeclarationinstantiation' + }, + EvaluateCall: { + url: 'https://262.ecma-international.org/9.0/#sec-evaluatecall' + }, + EvaluateNew: { + url: 'https://262.ecma-international.org/9.0/#sec-evaluatenew' + }, + EventSet: { + url: 'https://262.ecma-international.org/9.0/#sec-event-set' + }, + floor: { + url: 'https://262.ecma-international.org/9.0/#eqn-floor' + }, + ForBodyEvaluation: { + url: 'https://262.ecma-international.org/9.0/#sec-forbodyevaluation' + }, + 'ForIn/OfBodyEvaluation': { + url: 'https://262.ecma-international.org/9.0/#sec-runtime-semantics-forin-div-ofbodyevaluation-lhs-stmt-iterator-lhskind-labelset' + }, + 'ForIn/OfHeadEvaluation': { + url: 'https://262.ecma-international.org/9.0/#sec-runtime-semantics-forin-div-ofheadevaluation-tdznames-expr-iterationkind' + }, + FromPropertyDescriptor: { + url: 'https://262.ecma-international.org/9.0/#sec-frompropertydescriptor' + }, + FulfillPromise: { + url: 'https://262.ecma-international.org/9.0/#sec-fulfillpromise' + }, + FunctionAllocate: { + url: 'https://262.ecma-international.org/9.0/#sec-functionallocate' + }, + FunctionCreate: { + url: 'https://262.ecma-international.org/9.0/#sec-functioncreate' + }, + FunctionDeclarationInstantiation: { + url: 'https://262.ecma-international.org/9.0/#sec-functiondeclarationinstantiation' + }, + FunctionInitialize: { + url: 'https://262.ecma-international.org/9.0/#sec-functioninitialize' + }, + GeneratorFunctionCreate: { + url: 'https://262.ecma-international.org/9.0/#sec-generatorfunctioncreate' + }, + GeneratorResume: { + url: 'https://262.ecma-international.org/9.0/#sec-generatorresume' + }, + GeneratorResumeAbrupt: { + url: 'https://262.ecma-international.org/9.0/#sec-generatorresumeabrupt' + }, + GeneratorStart: { + url: 'https://262.ecma-international.org/9.0/#sec-generatorstart' + }, + GeneratorValidate: { + url: 'https://262.ecma-international.org/9.0/#sec-generatorvalidate' + }, + GeneratorYield: { + url: 'https://262.ecma-international.org/9.0/#sec-generatoryield' + }, + Get: { + url: 'https://262.ecma-international.org/9.0/#sec-get-o-p' + }, + GetActiveScriptOrModule: { + url: 'https://262.ecma-international.org/9.0/#sec-getactivescriptormodule' + }, + GetBase: { + url: 'https://262.ecma-international.org/9.0/#sec-getbase' + }, + GetFunctionRealm: { + url: 'https://262.ecma-international.org/9.0/#sec-getfunctionrealm' + }, + GetGeneratorKind: { + url: 'https://262.ecma-international.org/9.0/#sec-getgeneratorkind' + }, + GetGlobalObject: { + url: 'https://262.ecma-international.org/9.0/#sec-getglobalobject' + }, + GetIdentifierReference: { + url: 'https://262.ecma-international.org/9.0/#sec-getidentifierreference' + }, + GetIterator: { + url: 'https://262.ecma-international.org/9.0/#sec-getiterator' + }, + GetMethod: { + url: 'https://262.ecma-international.org/9.0/#sec-getmethod' + }, + GetModifySetValueInBuffer: { + url: 'https://262.ecma-international.org/9.0/#sec-getmodifysetvalueinbuffer' + }, + GetModuleNamespace: { + url: 'https://262.ecma-international.org/9.0/#sec-getmodulenamespace' + }, + GetNewTarget: { + url: 'https://262.ecma-international.org/9.0/#sec-getnewtarget' + }, + GetOwnPropertyKeys: { + url: 'https://262.ecma-international.org/9.0/#sec-getownpropertykeys' + }, + GetPrototypeFromConstructor: { + url: 'https://262.ecma-international.org/9.0/#sec-getprototypefromconstructor' + }, + GetReferencedName: { + url: 'https://262.ecma-international.org/9.0/#sec-getreferencedname' + }, + GetSubstitution: { + url: 'https://262.ecma-international.org/9.0/#sec-getsubstitution' + }, + GetSuperConstructor: { + url: 'https://262.ecma-international.org/9.0/#sec-getsuperconstructor' + }, + GetTemplateObject: { + url: 'https://262.ecma-international.org/9.0/#sec-gettemplateobject' + }, + GetThisEnvironment: { + url: 'https://262.ecma-international.org/9.0/#sec-getthisenvironment' + }, + GetThisValue: { + url: 'https://262.ecma-international.org/9.0/#sec-getthisvalue' + }, + GetV: { + url: 'https://262.ecma-international.org/9.0/#sec-getv' + }, + GetValue: { + url: 'https://262.ecma-international.org/9.0/#sec-getvalue' + }, + GetValueFromBuffer: { + url: 'https://262.ecma-international.org/9.0/#sec-getvaluefrombuffer' + }, + GetViewValue: { + url: 'https://262.ecma-international.org/9.0/#sec-getviewvalue' + }, + GetWaiterList: { + url: 'https://262.ecma-international.org/9.0/#sec-getwaiterlist' + }, + GlobalDeclarationInstantiation: { + url: 'https://262.ecma-international.org/9.0/#sec-globaldeclarationinstantiation' + }, + 'happens-before': { + url: 'https://262.ecma-international.org/9.0/#sec-happens-before' + }, + HasOwnProperty: { + url: 'https://262.ecma-international.org/9.0/#sec-hasownproperty' + }, + HasPrimitiveBase: { + url: 'https://262.ecma-international.org/9.0/#sec-hasprimitivebase' + }, + HasProperty: { + url: 'https://262.ecma-international.org/9.0/#sec-hasproperty' + }, + 'host-synchronizes-with': { + url: 'https://262.ecma-international.org/9.0/#sec-host-synchronizes-with' + }, + HostEventSet: { + url: 'https://262.ecma-international.org/9.0/#sec-hosteventset' + }, + HourFromTime: { + url: 'https://262.ecma-international.org/9.0/#eqn-HourFromTime' + }, + IfAbruptRejectPromise: { + url: 'https://262.ecma-international.org/9.0/#sec-ifabruptrejectpromise' + }, + ImportedLocalNames: { + url: 'https://262.ecma-international.org/9.0/#sec-importedlocalnames' + }, + InitializeBoundName: { + url: 'https://262.ecma-international.org/9.0/#sec-initializeboundname' + }, + InitializeHostDefinedRealm: { + url: 'https://262.ecma-international.org/9.0/#sec-initializehostdefinedrealm' + }, + InitializeReferencedBinding: { + url: 'https://262.ecma-international.org/9.0/#sec-initializereferencedbinding' + }, + InLeapYear: { + url: 'https://262.ecma-international.org/9.0/#eqn-InLeapYear' + }, + InnerModuleEvaluation: { + url: 'https://262.ecma-international.org/9.0/#sec-innermoduleevaluation' + }, + InnerModuleInstantiation: { + url: 'https://262.ecma-international.org/9.0/#sec-innermoduleinstantiation' + }, + InstanceofOperator: { + url: 'https://262.ecma-international.org/9.0/#sec-instanceofoperator' + }, + IntegerIndexedElementGet: { + url: 'https://262.ecma-international.org/9.0/#sec-integerindexedelementget' + }, + IntegerIndexedElementSet: { + url: 'https://262.ecma-international.org/9.0/#sec-integerindexedelementset' + }, + IntegerIndexedObjectCreate: { + url: 'https://262.ecma-international.org/9.0/#sec-integerindexedobjectcreate' + }, + InternalizeJSONProperty: { + url: 'https://262.ecma-international.org/9.0/#sec-internalizejsonproperty' + }, + Invoke: { + url: 'https://262.ecma-international.org/9.0/#sec-invoke' + }, + IsAccessorDescriptor: { + url: 'https://262.ecma-international.org/9.0/#sec-isaccessordescriptor' + }, + IsAnonymousFunctionDefinition: { + url: 'https://262.ecma-international.org/9.0/#sec-isanonymousfunctiondefinition' + }, + IsArray: { + url: 'https://262.ecma-international.org/9.0/#sec-isarray' + }, + IsCallable: { + url: 'https://262.ecma-international.org/9.0/#sec-iscallable' + }, + IsCompatiblePropertyDescriptor: { + url: 'https://262.ecma-international.org/9.0/#sec-iscompatiblepropertydescriptor' + }, + IsConcatSpreadable: { + url: 'https://262.ecma-international.org/9.0/#sec-isconcatspreadable' + }, + IsConstructor: { + url: 'https://262.ecma-international.org/9.0/#sec-isconstructor' + }, + IsDataDescriptor: { + url: 'https://262.ecma-international.org/9.0/#sec-isdatadescriptor' + }, + IsDetachedBuffer: { + url: 'https://262.ecma-international.org/9.0/#sec-isdetachedbuffer' + }, + IsExtensible: { + url: 'https://262.ecma-international.org/9.0/#sec-isextensible-o' + }, + IsGenericDescriptor: { + url: 'https://262.ecma-international.org/9.0/#sec-isgenericdescriptor' + }, + IsInTailPosition: { + url: 'https://262.ecma-international.org/9.0/#sec-isintailposition' + }, + IsInteger: { + url: 'https://262.ecma-international.org/9.0/#sec-isinteger' + }, + IsLabelledFunction: { + url: 'https://262.ecma-international.org/9.0/#sec-islabelledfunction' + }, + IsPromise: { + url: 'https://262.ecma-international.org/9.0/#sec-ispromise' + }, + IsPropertyKey: { + url: 'https://262.ecma-international.org/9.0/#sec-ispropertykey' + }, + IsPropertyReference: { + url: 'https://262.ecma-international.org/9.0/#sec-ispropertyreference' + }, + IsRegExp: { + url: 'https://262.ecma-international.org/9.0/#sec-isregexp' + }, + IsSharedArrayBuffer: { + url: 'https://262.ecma-international.org/9.0/#sec-issharedarraybuffer' + }, + IsStrictReference: { + url: 'https://262.ecma-international.org/9.0/#sec-isstrictreference' + }, + IsStringPrefix: { + url: 'https://262.ecma-international.org/9.0/#sec-isstringprefix' + }, + IsSuperReference: { + url: 'https://262.ecma-international.org/9.0/#sec-issuperreference' + }, + IsUnresolvableReference: { + url: 'https://262.ecma-international.org/9.0/#sec-isunresolvablereference' + }, + IsWordChar: { + url: 'https://262.ecma-international.org/9.0/#sec-runtime-semantics-iswordchar-abstract-operation' + }, + IterableToList: { + url: 'https://262.ecma-international.org/9.0/#sec-iterabletolist' + }, + IteratorClose: { + url: 'https://262.ecma-international.org/9.0/#sec-iteratorclose' + }, + IteratorComplete: { + url: 'https://262.ecma-international.org/9.0/#sec-iteratorcomplete' + }, + IteratorNext: { + url: 'https://262.ecma-international.org/9.0/#sec-iteratornext' + }, + IteratorStep: { + url: 'https://262.ecma-international.org/9.0/#sec-iteratorstep' + }, + IteratorValue: { + url: 'https://262.ecma-international.org/9.0/#sec-iteratorvalue' + }, + LeaveCriticalSection: { + url: 'https://262.ecma-international.org/9.0/#sec-leavecriticalsection' + }, + LocalTime: { + url: 'https://262.ecma-international.org/9.0/#sec-localtime' + }, + LoopContinues: { + url: 'https://262.ecma-international.org/9.0/#sec-loopcontinues' + }, + MakeArgGetter: { + url: 'https://262.ecma-international.org/9.0/#sec-makearggetter' + }, + MakeArgSetter: { + url: 'https://262.ecma-international.org/9.0/#sec-makeargsetter' + }, + MakeClassConstructor: { + url: 'https://262.ecma-international.org/9.0/#sec-makeclassconstructor' + }, + MakeConstructor: { + url: 'https://262.ecma-international.org/9.0/#sec-makeconstructor' + }, + MakeDate: { + url: 'https://262.ecma-international.org/9.0/#sec-makedate' + }, + MakeDay: { + url: 'https://262.ecma-international.org/9.0/#sec-makeday' + }, + MakeMethod: { + url: 'https://262.ecma-international.org/9.0/#sec-makemethod' + }, + MakeSuperPropertyReference: { + url: 'https://262.ecma-international.org/9.0/#sec-makesuperpropertyreference' + }, + MakeTime: { + url: 'https://262.ecma-international.org/9.0/#sec-maketime' + }, + max: { + url: 'https://262.ecma-international.org/9.0/#eqn-max' + }, + 'memory-order': { + url: 'https://262.ecma-international.org/9.0/#sec-memory-order' + }, + min: { + url: 'https://262.ecma-international.org/9.0/#eqn-min' + }, + MinFromTime: { + url: 'https://262.ecma-international.org/9.0/#eqn-MinFromTime' + }, + ModuleDeclarationEnvironmentSetup: { + url: 'https://262.ecma-international.org/9.0/#sec-moduledeclarationenvironmentsetup' + }, + ModuleExecution: { + url: 'https://262.ecma-international.org/9.0/#sec-moduleexecution' + }, + ModuleNamespaceCreate: { + url: 'https://262.ecma-international.org/9.0/#sec-modulenamespacecreate' + }, + modulo: { + url: 'https://262.ecma-international.org/9.0/#eqn-modulo' + }, + MonthFromTime: { + url: 'https://262.ecma-international.org/9.0/#eqn-MonthFromTime' + }, + msFromTime: { + url: 'https://262.ecma-international.org/9.0/#eqn-msFromTime' + }, + NewDeclarativeEnvironment: { + url: 'https://262.ecma-international.org/9.0/#sec-newdeclarativeenvironment' + }, + NewFunctionEnvironment: { + url: 'https://262.ecma-international.org/9.0/#sec-newfunctionenvironment' + }, + NewGlobalEnvironment: { + url: 'https://262.ecma-international.org/9.0/#sec-newglobalenvironment' + }, + NewModuleEnvironment: { + url: 'https://262.ecma-international.org/9.0/#sec-newmoduleenvironment' + }, + NewObjectEnvironment: { + url: 'https://262.ecma-international.org/9.0/#sec-newobjectenvironment' + }, + NewPromiseCapability: { + url: 'https://262.ecma-international.org/9.0/#sec-newpromisecapability' + }, + NormalCompletion: { + url: 'https://262.ecma-international.org/9.0/#sec-normalcompletion' + }, + NumberToRawBytes: { + url: 'https://262.ecma-international.org/9.0/#sec-numbertorawbytes' + }, + NumberToString: { + url: 'https://262.ecma-international.org/9.0/#sec-tostring-applied-to-the-number-type' + }, + ObjectCreate: { + url: 'https://262.ecma-international.org/9.0/#sec-objectcreate' + }, + ObjectDefineProperties: { + url: 'https://262.ecma-international.org/9.0/#sec-objectdefineproperties' + }, + OrdinaryCallBindThis: { + url: 'https://262.ecma-international.org/9.0/#sec-ordinarycallbindthis' + }, + OrdinaryCallEvaluateBody: { + url: 'https://262.ecma-international.org/9.0/#sec-ordinarycallevaluatebody' + }, + OrdinaryCreateFromConstructor: { + url: 'https://262.ecma-international.org/9.0/#sec-ordinarycreatefromconstructor' + }, + OrdinaryDefineOwnProperty: { + url: 'https://262.ecma-international.org/9.0/#sec-ordinarydefineownproperty' + }, + OrdinaryDelete: { + url: 'https://262.ecma-international.org/9.0/#sec-ordinarydelete' + }, + OrdinaryGet: { + url: 'https://262.ecma-international.org/9.0/#sec-ordinaryget' + }, + OrdinaryGetOwnProperty: { + url: 'https://262.ecma-international.org/9.0/#sec-ordinarygetownproperty' + }, + OrdinaryGetPrototypeOf: { + url: 'https://262.ecma-international.org/9.0/#sec-ordinarygetprototypeof' + }, + OrdinaryHasInstance: { + url: 'https://262.ecma-international.org/9.0/#sec-ordinaryhasinstance' + }, + OrdinaryHasProperty: { + url: 'https://262.ecma-international.org/9.0/#sec-ordinaryhasproperty' + }, + OrdinaryIsExtensible: { + url: 'https://262.ecma-international.org/9.0/#sec-ordinaryisextensible' + }, + OrdinaryOwnPropertyKeys: { + url: 'https://262.ecma-international.org/9.0/#sec-ordinaryownpropertykeys' + }, + OrdinaryPreventExtensions: { + url: 'https://262.ecma-international.org/9.0/#sec-ordinarypreventextensions' + }, + OrdinarySet: { + url: 'https://262.ecma-international.org/9.0/#sec-ordinaryset' + }, + OrdinarySetPrototypeOf: { + url: 'https://262.ecma-international.org/9.0/#sec-ordinarysetprototypeof' + }, + OrdinarySetWithOwnDescriptor: { + url: 'https://262.ecma-international.org/9.0/#sec-ordinarysetwithowndescriptor' + }, + OrdinaryToPrimitive: { + url: 'https://262.ecma-international.org/9.0/#sec-ordinarytoprimitive' + }, + ParseModule: { + url: 'https://262.ecma-international.org/9.0/#sec-parsemodule' + }, + ParseScript: { + url: 'https://262.ecma-international.org/9.0/#sec-parse-script' + }, + PerformEval: { + url: 'https://262.ecma-international.org/9.0/#sec-performeval' + }, + PerformPromiseAll: { + url: 'https://262.ecma-international.org/9.0/#sec-performpromiseall' + }, + PerformPromiseRace: { + url: 'https://262.ecma-international.org/9.0/#sec-performpromiserace' + }, + PerformPromiseThen: { + url: 'https://262.ecma-international.org/9.0/#sec-performpromisethen' + }, + PrepareForOrdinaryCall: { + url: 'https://262.ecma-international.org/9.0/#sec-prepareforordinarycall' + }, + PrepareForTailCall: { + url: 'https://262.ecma-international.org/9.0/#sec-preparefortailcall' + }, + PromiseReactionJob: { + url: 'https://262.ecma-international.org/9.0/#sec-promisereactionjob' + }, + PromiseResolve: { + url: 'https://262.ecma-international.org/9.0/#sec-promise-resolve' + }, + PromiseResolveThenableJob: { + url: 'https://262.ecma-international.org/9.0/#sec-promiseresolvethenablejob' + }, + ProxyCreate: { + url: 'https://262.ecma-international.org/9.0/#sec-proxycreate' + }, + PutValue: { + url: 'https://262.ecma-international.org/9.0/#sec-putvalue' + }, + QuoteJSONString: { + url: 'https://262.ecma-international.org/9.0/#sec-quotejsonstring' + }, + RawBytesToNumber: { + url: 'https://262.ecma-international.org/9.0/#sec-rawbytestonumber' + }, + 'reads-bytes-from': { + url: 'https://262.ecma-international.org/9.0/#sec-reads-bytes-from' + }, + 'reads-from': { + url: 'https://262.ecma-international.org/9.0/#sec-reads-from' + }, + RegExpAlloc: { + url: 'https://262.ecma-international.org/9.0/#sec-regexpalloc' + }, + RegExpBuiltinExec: { + url: 'https://262.ecma-international.org/9.0/#sec-regexpbuiltinexec' + }, + RegExpCreate: { + url: 'https://262.ecma-international.org/9.0/#sec-regexpcreate' + }, + RegExpExec: { + url: 'https://262.ecma-international.org/9.0/#sec-regexpexec' + }, + RegExpInitialize: { + url: 'https://262.ecma-international.org/9.0/#sec-regexpinitialize' + }, + RejectPromise: { + url: 'https://262.ecma-international.org/9.0/#sec-rejectpromise' + }, + RemoveWaiter: { + url: 'https://262.ecma-international.org/9.0/#sec-removewaiter' + }, + RemoveWaiters: { + url: 'https://262.ecma-international.org/9.0/#sec-removewaiters' + }, + RepeatMatcher: { + url: 'https://262.ecma-international.org/9.0/#sec-runtime-semantics-repeatmatcher-abstract-operation' + }, + RequireObjectCoercible: { + url: 'https://262.ecma-international.org/9.0/#sec-requireobjectcoercible' + }, + ResolveBinding: { + url: 'https://262.ecma-international.org/9.0/#sec-resolvebinding' + }, + ResolveThisBinding: { + url: 'https://262.ecma-international.org/9.0/#sec-resolvethisbinding' + }, + ReturnIfAbrupt: { + url: 'https://262.ecma-international.org/9.0/#sec-returnifabrupt' + }, + RunJobs: { + url: 'https://262.ecma-international.org/9.0/#sec-runjobs' + }, + SameValue: { + url: 'https://262.ecma-international.org/9.0/#sec-samevalue' + }, + SameValueNonNumber: { + url: 'https://262.ecma-international.org/9.0/#sec-samevaluenonnumber' + }, + SameValueZero: { + url: 'https://262.ecma-international.org/9.0/#sec-samevaluezero' + }, + ScriptEvaluation: { + url: 'https://262.ecma-international.org/9.0/#sec-runtime-semantics-scriptevaluation' + }, + ScriptEvaluationJob: { + url: 'https://262.ecma-international.org/9.0/#sec-scriptevaluationjob' + }, + SecFromTime: { + url: 'https://262.ecma-international.org/9.0/#eqn-SecFromTime' + }, + SerializeJSONArray: { + url: 'https://262.ecma-international.org/9.0/#sec-serializejsonarray' + }, + SerializeJSONObject: { + url: 'https://262.ecma-international.org/9.0/#sec-serializejsonobject' + }, + SerializeJSONProperty: { + url: 'https://262.ecma-international.org/9.0/#sec-serializejsonproperty' + }, + Set: { + url: 'https://262.ecma-international.org/9.0/#sec-set-o-p-v-throw' + }, + SetDefaultGlobalBindings: { + url: 'https://262.ecma-international.org/9.0/#sec-setdefaultglobalbindings' + }, + SetFunctionLength: { + url: 'https://262.ecma-international.org/9.0/#sec-setfunctionlength' + }, + SetFunctionName: { + url: 'https://262.ecma-international.org/9.0/#sec-setfunctionname' + }, + SetImmutablePrototype: { + url: 'https://262.ecma-international.org/9.0/#sec-set-immutable-prototype' + }, + SetIntegrityLevel: { + url: 'https://262.ecma-international.org/9.0/#sec-setintegritylevel' + }, + SetRealmGlobalObject: { + url: 'https://262.ecma-international.org/9.0/#sec-setrealmglobalobject' + }, + SetValueInBuffer: { + url: 'https://262.ecma-international.org/9.0/#sec-setvalueinbuffer' + }, + SetViewValue: { + url: 'https://262.ecma-international.org/9.0/#sec-setviewvalue' + }, + SharedDataBlockEventSet: { + url: 'https://262.ecma-international.org/9.0/#sec-sharedatablockeventset' + }, + SortCompare: { + url: 'https://262.ecma-international.org/9.0/#sec-sortcompare' + }, + SpeciesConstructor: { + url: 'https://262.ecma-international.org/9.0/#sec-speciesconstructor' + }, + SplitMatch: { + url: 'https://262.ecma-international.org/9.0/#sec-splitmatch' + }, + 'Strict Equality Comparison': { + url: 'https://262.ecma-international.org/9.0/#sec-strict-equality-comparison' + }, + StringCreate: { + url: 'https://262.ecma-international.org/9.0/#sec-stringcreate' + }, + StringGetOwnProperty: { + url: 'https://262.ecma-international.org/9.0/#sec-stringgetownproperty' + }, + Suspend: { + url: 'https://262.ecma-international.org/9.0/#sec-suspend' + }, + SymbolDescriptiveString: { + url: 'https://262.ecma-international.org/9.0/#sec-symboldescriptivestring' + }, + 'synchronizes-with': { + url: 'https://262.ecma-international.org/9.0/#sec-synchronizes-with' + }, + TestIntegrityLevel: { + url: 'https://262.ecma-international.org/9.0/#sec-testintegritylevel' + }, + thisBooleanValue: { + url: 'https://262.ecma-international.org/9.0/#sec-thisbooleanvalue' + }, + thisNumberValue: { + url: 'https://262.ecma-international.org/9.0/#sec-thisnumbervalue' + }, + thisStringValue: { + url: 'https://262.ecma-international.org/9.0/#sec-thisstringvalue' + }, + thisSymbolValue: { + url: 'https://262.ecma-international.org/9.0/#sec-thissymbolvalue' + }, + thisTimeValue: { + url: 'https://262.ecma-international.org/9.0/#sec-thistimevalue' + }, + ThrowCompletion: { + url: 'https://262.ecma-international.org/9.0/#sec-throwcompletion' + }, + TimeClip: { + url: 'https://262.ecma-international.org/9.0/#sec-timeclip' + }, + TimeFromYear: { + url: 'https://262.ecma-international.org/9.0/#eqn-TimeFromYear' + }, + TimeString: { + url: 'https://262.ecma-international.org/9.0/#sec-timestring' + }, + TimeWithinDay: { + url: 'https://262.ecma-international.org/9.0/#eqn-TimeWithinDay' + }, + TimeZoneString: { + url: 'https://262.ecma-international.org/9.0/#sec-timezoneestring' + }, + ToBoolean: { + url: 'https://262.ecma-international.org/9.0/#sec-toboolean' + }, + ToDateString: { + url: 'https://262.ecma-international.org/9.0/#sec-todatestring' + }, + ToIndex: { + url: 'https://262.ecma-international.org/9.0/#sec-toindex' + }, + ToInt16: { + url: 'https://262.ecma-international.org/9.0/#sec-toint16' + }, + ToInt32: { + url: 'https://262.ecma-international.org/9.0/#sec-toint32' + }, + ToInt8: { + url: 'https://262.ecma-international.org/9.0/#sec-toint8' + }, + ToInteger: { + url: 'https://262.ecma-international.org/9.0/#sec-tointeger' + }, + ToLength: { + url: 'https://262.ecma-international.org/9.0/#sec-tolength' + }, + ToNumber: { + url: 'https://262.ecma-international.org/9.0/#sec-tonumber' + }, + ToObject: { + url: 'https://262.ecma-international.org/9.0/#sec-toobject' + }, + TopLevelModuleEvaluationJob: { + url: 'https://262.ecma-international.org/9.0/#sec-toplevelmoduleevaluationjob' + }, + ToPrimitive: { + url: 'https://262.ecma-international.org/9.0/#sec-toprimitive' + }, + ToPropertyDescriptor: { + url: 'https://262.ecma-international.org/9.0/#sec-topropertydescriptor' + }, + ToPropertyKey: { + url: 'https://262.ecma-international.org/9.0/#sec-topropertykey' + }, + ToString: { + url: 'https://262.ecma-international.org/9.0/#sec-tostring' + }, + ToUint16: { + url: 'https://262.ecma-international.org/9.0/#sec-touint16' + }, + ToUint32: { + url: 'https://262.ecma-international.org/9.0/#sec-touint32' + }, + ToUint8: { + url: 'https://262.ecma-international.org/9.0/#sec-touint8' + }, + ToUint8Clamp: { + url: 'https://262.ecma-international.org/9.0/#sec-touint8clamp' + }, + TriggerPromiseReactions: { + url: 'https://262.ecma-international.org/9.0/#sec-triggerpromisereactions' + }, + Type: { + url: 'https://262.ecma-international.org/9.0/#sec-ecmascript-data-types-and-values' + }, + TypedArrayCreate: { + url: 'https://262.ecma-international.org/9.0/#typedarray-create' + }, + TypedArraySpeciesCreate: { + url: 'https://262.ecma-international.org/9.0/#typedarray-species-create' + }, + UnicodeEscape: { + url: 'https://262.ecma-international.org/9.0/#sec-unicodeescape' + }, + UnicodeMatchProperty: { + url: 'https://262.ecma-international.org/9.0/#sec-runtime-semantics-unicodematchproperty-p' + }, + UnicodeMatchPropertyValue: { + url: 'https://262.ecma-international.org/9.0/#sec-runtime-semantics-unicodematchpropertyvalue-p-v' + }, + UpdateEmpty: { + url: 'https://262.ecma-international.org/9.0/#sec-updateempty' + }, + UTC: { + url: 'https://262.ecma-international.org/9.0/#sec-utc-t' + }, + UTF16Decode: { + url: 'https://262.ecma-international.org/9.0/#sec-utf16decode' + }, + UTF16Encoding: { + url: 'https://262.ecma-international.org/9.0/#sec-utf16encoding' + }, + ValidateAndApplyPropertyDescriptor: { + url: 'https://262.ecma-international.org/9.0/#sec-validateandapplypropertydescriptor' + }, + ValidateAtomicAccess: { + url: 'https://262.ecma-international.org/9.0/#sec-validateatomicaccess' + }, + ValidateSharedIntegerTypedArray: { + url: 'https://262.ecma-international.org/9.0/#sec-validatesharedintegertypedarray' + }, + ValidateTypedArray: { + url: 'https://262.ecma-international.org/9.0/#sec-validatetypedarray' + }, + ValueOfReadEvent: { + url: 'https://262.ecma-international.org/9.0/#sec-valueofreadevent' + }, + WakeWaiter: { + url: 'https://262.ecma-international.org/9.0/#sec-wakewaiter' + }, + WeekDay: { + url: 'https://262.ecma-international.org/9.0/#sec-week-day' + }, + WordCharacters: { + url: 'https://262.ecma-international.org/9.0/#sec-runtime-semantics-wordcharacters-abstract-operation' + }, + YearFromTime: { + url: 'https://262.ecma-international.org/9.0/#eqn-YearFromTime' + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2019.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2019.js new file mode 100644 index 0000000000000000000000000000000000000000..d19150c8dc45cdde052f3a3a6a9ad3017bc5f570 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2019.js @@ -0,0 +1,1048 @@ +'use strict'; + +module.exports = { + abs: { + url: 'https://262.ecma-international.org/10.0/#eqn-abs' + }, + 'Abstract Equality Comparison': { + url: 'https://262.ecma-international.org/10.0/#sec-abstract-equality-comparison' + }, + 'Abstract Relational Comparison': { + url: 'https://262.ecma-international.org/10.0/#sec-abstract-relational-comparison' + }, + AddEntriesFromIterable: { + url: 'https://262.ecma-international.org/10.0/#sec-add-entries-from-iterable' + }, + AddRestrictedFunctionProperties: { + url: 'https://262.ecma-international.org/10.0/#sec-addrestrictedfunctionproperties' + }, + AddWaiter: { + url: 'https://262.ecma-international.org/10.0/#sec-addwaiter' + }, + AdvanceStringIndex: { + url: 'https://262.ecma-international.org/10.0/#sec-advancestringindex' + }, + 'agent-order': { + url: 'https://262.ecma-international.org/10.0/#sec-agent-order' + }, + AgentCanSuspend: { + url: 'https://262.ecma-international.org/10.0/#sec-agentcansuspend' + }, + AgentSignifier: { + url: 'https://262.ecma-international.org/10.0/#sec-agentsignifier' + }, + AllocateArrayBuffer: { + url: 'https://262.ecma-international.org/10.0/#sec-allocatearraybuffer' + }, + AllocateSharedArrayBuffer: { + url: 'https://262.ecma-international.org/10.0/#sec-allocatesharedarraybuffer' + }, + AllocateTypedArray: { + url: 'https://262.ecma-international.org/10.0/#sec-allocatetypedarray' + }, + AllocateTypedArrayBuffer: { + url: 'https://262.ecma-international.org/10.0/#sec-allocatetypedarraybuffer' + }, + ArrayCreate: { + url: 'https://262.ecma-international.org/10.0/#sec-arraycreate' + }, + ArraySetLength: { + url: 'https://262.ecma-international.org/10.0/#sec-arraysetlength' + }, + ArraySpeciesCreate: { + url: 'https://262.ecma-international.org/10.0/#sec-arrayspeciescreate' + }, + AsyncFromSyncIteratorContinuation: { + url: 'https://262.ecma-international.org/10.0/#sec-asyncfromsynciteratorcontinuation' + }, + AsyncFunctionCreate: { + url: 'https://262.ecma-international.org/10.0/#sec-async-functions-abstract-operations-async-function-create' + }, + AsyncFunctionStart: { + url: 'https://262.ecma-international.org/10.0/#sec-async-functions-abstract-operations-async-function-start' + }, + AsyncGeneratorEnqueue: { + url: 'https://262.ecma-international.org/10.0/#sec-asyncgeneratorenqueue' + }, + AsyncGeneratorFunctionCreate: { + url: 'https://262.ecma-international.org/10.0/#sec-asyncgeneratorfunctioncreate' + }, + AsyncGeneratorReject: { + url: 'https://262.ecma-international.org/10.0/#sec-asyncgeneratorreject' + }, + AsyncGeneratorResolve: { + url: 'https://262.ecma-international.org/10.0/#sec-asyncgeneratorresolve' + }, + AsyncGeneratorResumeNext: { + url: 'https://262.ecma-international.org/10.0/#sec-asyncgeneratorresumenext' + }, + AsyncGeneratorStart: { + url: 'https://262.ecma-international.org/10.0/#sec-asyncgeneratorstart' + }, + AsyncGeneratorYield: { + url: 'https://262.ecma-international.org/10.0/#sec-asyncgeneratoryield' + }, + AsyncIteratorClose: { + url: 'https://262.ecma-international.org/10.0/#sec-asynciteratorclose' + }, + AtomicLoad: { + url: 'https://262.ecma-international.org/10.0/#sec-atomicload' + }, + AtomicReadModifyWrite: { + url: 'https://262.ecma-international.org/10.0/#sec-atomicreadmodifywrite' + }, + Await: { + url: 'https://262.ecma-international.org/10.0/#await' + }, + BackreferenceMatcher: { + url: 'https://262.ecma-international.org/10.0/#sec-backreference-matcher' + }, + BlockDeclarationInstantiation: { + url: 'https://262.ecma-international.org/10.0/#sec-blockdeclarationinstantiation' + }, + BoundFunctionCreate: { + url: 'https://262.ecma-international.org/10.0/#sec-boundfunctioncreate' + }, + Call: { + url: 'https://262.ecma-international.org/10.0/#sec-call' + }, + Canonicalize: { + url: 'https://262.ecma-international.org/10.0/#sec-runtime-semantics-canonicalize-ch' + }, + CanonicalNumericIndexString: { + url: 'https://262.ecma-international.org/10.0/#sec-canonicalnumericindexstring' + }, + CaseClauseIsSelected: { + url: 'https://262.ecma-international.org/10.0/#sec-runtime-semantics-caseclauseisselected' + }, + CharacterRange: { + url: 'https://262.ecma-international.org/10.0/#sec-runtime-semantics-characterrange-abstract-operation' + }, + CharacterRangeOrUnion: { + url: 'https://262.ecma-international.org/10.0/#sec-runtime-semantics-characterrangeorunion-abstract-operation' + }, + CharacterSetMatcher: { + url: 'https://262.ecma-international.org/10.0/#sec-runtime-semantics-charactersetmatcher-abstract-operation' + }, + CloneArrayBuffer: { + url: 'https://262.ecma-international.org/10.0/#sec-clonearraybuffer' + }, + CompletePropertyDescriptor: { + url: 'https://262.ecma-international.org/10.0/#sec-completepropertydescriptor' + }, + Completion: { + url: 'https://262.ecma-international.org/10.0/#sec-completion-record-specification-type' + }, + CompletionRecord: { + url: 'https://262.ecma-international.org/10.0/#sec-completion-record-specification-type' + }, + ComposeWriteEventBytes: { + url: 'https://262.ecma-international.org/10.0/#sec-composewriteeventbytes' + }, + Construct: { + url: 'https://262.ecma-international.org/10.0/#sec-construct' + }, + CopyDataBlockBytes: { + url: 'https://262.ecma-international.org/10.0/#sec-copydatablockbytes' + }, + CopyDataProperties: { + url: 'https://262.ecma-international.org/10.0/#sec-copydataproperties' + }, + CreateArrayFromList: { + url: 'https://262.ecma-international.org/10.0/#sec-createarrayfromlist' + }, + CreateArrayIterator: { + url: 'https://262.ecma-international.org/10.0/#sec-createarrayiterator' + }, + CreateAsyncFromSyncIterator: { + url: 'https://262.ecma-international.org/10.0/#sec-createasyncfromsynciterator' + }, + CreateBuiltinFunction: { + url: 'https://262.ecma-international.org/10.0/#sec-createbuiltinfunction' + }, + CreateByteDataBlock: { + url: 'https://262.ecma-international.org/10.0/#sec-createbytedatablock' + }, + CreateDataProperty: { + url: 'https://262.ecma-international.org/10.0/#sec-createdataproperty' + }, + CreateDataPropertyOrThrow: { + url: 'https://262.ecma-international.org/10.0/#sec-createdatapropertyorthrow' + }, + CreateDynamicFunction: { + url: 'https://262.ecma-international.org/10.0/#sec-createdynamicfunction' + }, + CreateHTML: { + url: 'https://262.ecma-international.org/10.0/#sec-createhtml' + }, + CreateIntrinsics: { + url: 'https://262.ecma-international.org/10.0/#sec-createintrinsics' + }, + CreateIterResultObject: { + url: 'https://262.ecma-international.org/10.0/#sec-createiterresultobject' + }, + CreateListFromArrayLike: { + url: 'https://262.ecma-international.org/10.0/#sec-createlistfromarraylike' + }, + CreateListIteratorRecord: { + url: 'https://262.ecma-international.org/10.0/#sec-createlistiteratorRecord' + }, + CreateMapIterator: { + url: 'https://262.ecma-international.org/10.0/#sec-createmapiterator' + }, + CreateMappedArgumentsObject: { + url: 'https://262.ecma-international.org/10.0/#sec-createmappedargumentsobject' + }, + CreateMethodProperty: { + url: 'https://262.ecma-international.org/10.0/#sec-createmethodproperty' + }, + CreatePerIterationEnvironment: { + url: 'https://262.ecma-international.org/10.0/#sec-createperiterationenvironment' + }, + CreateRealm: { + url: 'https://262.ecma-international.org/10.0/#sec-createrealm' + }, + CreateResolvingFunctions: { + url: 'https://262.ecma-international.org/10.0/#sec-createresolvingfunctions' + }, + CreateSetIterator: { + url: 'https://262.ecma-international.org/10.0/#sec-createsetiterator' + }, + CreateSharedByteDataBlock: { + url: 'https://262.ecma-international.org/10.0/#sec-createsharedbytedatablock' + }, + CreateStringIterator: { + url: 'https://262.ecma-international.org/10.0/#sec-createstringiterator' + }, + CreateUnmappedArgumentsObject: { + url: 'https://262.ecma-international.org/10.0/#sec-createunmappedargumentsobject' + }, + DateFromTime: { + url: 'https://262.ecma-international.org/10.0/#sec-date-number' + }, + DateString: { + url: 'https://262.ecma-international.org/10.0/#sec-datestring' + }, + Day: { + url: 'https://262.ecma-international.org/10.0/#eqn-Day' + }, + DayFromYear: { + url: 'https://262.ecma-international.org/10.0/#eqn-DaysFromYear' + }, + DaysInYear: { + url: 'https://262.ecma-international.org/10.0/#eqn-DaysInYear' + }, + DayWithinYear: { + url: 'https://262.ecma-international.org/10.0/#eqn-DayWithinYear' + }, + Decode: { + url: 'https://262.ecma-international.org/10.0/#sec-decode' + }, + DefinePropertyOrThrow: { + url: 'https://262.ecma-international.org/10.0/#sec-definepropertyorthrow' + }, + DeletePropertyOrThrow: { + url: 'https://262.ecma-international.org/10.0/#sec-deletepropertyorthrow' + }, + DetachArrayBuffer: { + url: 'https://262.ecma-international.org/10.0/#sec-detacharraybuffer' + }, + Encode: { + url: 'https://262.ecma-international.org/10.0/#sec-encode' + }, + EnqueueJob: { + url: 'https://262.ecma-international.org/10.0/#sec-enqueuejob' + }, + EnterCriticalSection: { + url: 'https://262.ecma-international.org/10.0/#sec-entercriticalsection' + }, + EnumerableOwnPropertyNames: { + url: 'https://262.ecma-international.org/10.0/#sec-enumerableownpropertynames' + }, + EnumerateObjectProperties: { + url: 'https://262.ecma-international.org/10.0/#sec-enumerate-object-properties' + }, + EscapeRegExpPattern: { + url: 'https://262.ecma-international.org/10.0/#sec-escaperegexppattern' + }, + EvalDeclarationInstantiation: { + url: 'https://262.ecma-international.org/10.0/#sec-evaldeclarationinstantiation' + }, + EvaluateCall: { + url: 'https://262.ecma-international.org/10.0/#sec-evaluatecall' + }, + EvaluateNew: { + url: 'https://262.ecma-international.org/10.0/#sec-evaluatenew' + }, + EventSet: { + url: 'https://262.ecma-international.org/10.0/#sec-event-set' + }, + ExecuteModule: { + url: 'https://262.ecma-international.org/10.0/#sec-source-text-module-record-execute-module' + }, + FlattenIntoArray: { + url: 'https://262.ecma-international.org/10.0/#sec-flattenintoarray' + }, + floor: { + url: 'https://262.ecma-international.org/10.0/#eqn-floor' + }, + ForBodyEvaluation: { + url: 'https://262.ecma-international.org/10.0/#sec-forbodyevaluation' + }, + 'ForIn/OfBodyEvaluation': { + url: 'https://262.ecma-international.org/10.0/#sec-runtime-semantics-forin-div-ofbodyevaluation-lhs-stmt-iterator-lhskind-labelset' + }, + 'ForIn/OfHeadEvaluation': { + url: 'https://262.ecma-international.org/10.0/#sec-runtime-semantics-forin-div-ofheadevaluation-tdznames-expr-iterationkind' + }, + FromPropertyDescriptor: { + url: 'https://262.ecma-international.org/10.0/#sec-frompropertydescriptor' + }, + FulfillPromise: { + url: 'https://262.ecma-international.org/10.0/#sec-fulfillpromise' + }, + FunctionAllocate: { + url: 'https://262.ecma-international.org/10.0/#sec-functionallocate' + }, + FunctionCreate: { + url: 'https://262.ecma-international.org/10.0/#sec-functioncreate' + }, + FunctionDeclarationInstantiation: { + url: 'https://262.ecma-international.org/10.0/#sec-functiondeclarationinstantiation' + }, + FunctionInitialize: { + url: 'https://262.ecma-international.org/10.0/#sec-functioninitialize' + }, + GeneratorFunctionCreate: { + url: 'https://262.ecma-international.org/10.0/#sec-generatorfunctioncreate' + }, + GeneratorResume: { + url: 'https://262.ecma-international.org/10.0/#sec-generatorresume' + }, + GeneratorResumeAbrupt: { + url: 'https://262.ecma-international.org/10.0/#sec-generatorresumeabrupt' + }, + GeneratorStart: { + url: 'https://262.ecma-international.org/10.0/#sec-generatorstart' + }, + GeneratorValidate: { + url: 'https://262.ecma-international.org/10.0/#sec-generatorvalidate' + }, + GeneratorYield: { + url: 'https://262.ecma-international.org/10.0/#sec-generatoryield' + }, + Get: { + url: 'https://262.ecma-international.org/10.0/#sec-get-o-p' + }, + GetActiveScriptOrModule: { + url: 'https://262.ecma-international.org/10.0/#sec-getactivescriptormodule' + }, + GetBase: { + url: 'https://262.ecma-international.org/10.0/#sec-getbase' + }, + GetFunctionRealm: { + url: 'https://262.ecma-international.org/10.0/#sec-getfunctionrealm' + }, + GetGeneratorKind: { + url: 'https://262.ecma-international.org/10.0/#sec-getgeneratorkind' + }, + GetGlobalObject: { + url: 'https://262.ecma-international.org/10.0/#sec-getglobalobject' + }, + GetIdentifierReference: { + url: 'https://262.ecma-international.org/10.0/#sec-getidentifierreference' + }, + GetIterator: { + url: 'https://262.ecma-international.org/10.0/#sec-getiterator' + }, + GetMethod: { + url: 'https://262.ecma-international.org/10.0/#sec-getmethod' + }, + GetModifySetValueInBuffer: { + url: 'https://262.ecma-international.org/10.0/#sec-getmodifysetvalueinbuffer' + }, + GetModuleNamespace: { + url: 'https://262.ecma-international.org/10.0/#sec-getmodulenamespace' + }, + GetNewTarget: { + url: 'https://262.ecma-international.org/10.0/#sec-getnewtarget' + }, + GetOwnPropertyKeys: { + url: 'https://262.ecma-international.org/10.0/#sec-getownpropertykeys' + }, + GetPrototypeFromConstructor: { + url: 'https://262.ecma-international.org/10.0/#sec-getprototypefromconstructor' + }, + GetReferencedName: { + url: 'https://262.ecma-international.org/10.0/#sec-getreferencedname' + }, + GetSubstitution: { + url: 'https://262.ecma-international.org/10.0/#sec-getsubstitution' + }, + GetSuperConstructor: { + url: 'https://262.ecma-international.org/10.0/#sec-getsuperconstructor' + }, + GetTemplateObject: { + url: 'https://262.ecma-international.org/10.0/#sec-gettemplateobject' + }, + GetThisEnvironment: { + url: 'https://262.ecma-international.org/10.0/#sec-getthisenvironment' + }, + GetThisValue: { + url: 'https://262.ecma-international.org/10.0/#sec-getthisvalue' + }, + GetV: { + url: 'https://262.ecma-international.org/10.0/#sec-getv' + }, + GetValue: { + url: 'https://262.ecma-international.org/10.0/#sec-getvalue' + }, + GetValueFromBuffer: { + url: 'https://262.ecma-international.org/10.0/#sec-getvaluefrombuffer' + }, + GetViewValue: { + url: 'https://262.ecma-international.org/10.0/#sec-getviewvalue' + }, + GetWaiterList: { + url: 'https://262.ecma-international.org/10.0/#sec-getwaiterlist' + }, + GlobalDeclarationInstantiation: { + url: 'https://262.ecma-international.org/10.0/#sec-globaldeclarationinstantiation' + }, + 'happens-before': { + url: 'https://262.ecma-international.org/10.0/#sec-happens-before' + }, + HasOwnProperty: { + url: 'https://262.ecma-international.org/10.0/#sec-hasownproperty' + }, + HasPrimitiveBase: { + url: 'https://262.ecma-international.org/10.0/#sec-hasprimitivebase' + }, + HasProperty: { + url: 'https://262.ecma-international.org/10.0/#sec-hasproperty' + }, + 'host-synchronizes-with': { + url: 'https://262.ecma-international.org/10.0/#sec-host-synchronizes-with' + }, + HostEventSet: { + url: 'https://262.ecma-international.org/10.0/#sec-hosteventset' + }, + HourFromTime: { + url: 'https://262.ecma-international.org/10.0/#eqn-HourFromTime' + }, + IfAbruptRejectPromise: { + url: 'https://262.ecma-international.org/10.0/#sec-ifabruptrejectpromise' + }, + ImportedLocalNames: { + url: 'https://262.ecma-international.org/10.0/#sec-importedlocalnames' + }, + InitializeBoundName: { + url: 'https://262.ecma-international.org/10.0/#sec-initializeboundname' + }, + InitializeEnvironment: { + url: 'https://262.ecma-international.org/10.0/#sec-source-text-module-record-initialize-environment' + }, + InitializeHostDefinedRealm: { + url: 'https://262.ecma-international.org/10.0/#sec-initializehostdefinedrealm' + }, + InitializeReferencedBinding: { + url: 'https://262.ecma-international.org/10.0/#sec-initializereferencedbinding' + }, + InLeapYear: { + url: 'https://262.ecma-international.org/10.0/#eqn-InLeapYear' + }, + InnerModuleEvaluation: { + url: 'https://262.ecma-international.org/10.0/#sec-innermoduleevaluation' + }, + InnerModuleInstantiation: { + url: 'https://262.ecma-international.org/10.0/#sec-innermoduleinstantiation' + }, + InstanceofOperator: { + url: 'https://262.ecma-international.org/10.0/#sec-instanceofoperator' + }, + IntegerIndexedElementGet: { + url: 'https://262.ecma-international.org/10.0/#sec-integerindexedelementget' + }, + IntegerIndexedElementSet: { + url: 'https://262.ecma-international.org/10.0/#sec-integerindexedelementset' + }, + IntegerIndexedObjectCreate: { + url: 'https://262.ecma-international.org/10.0/#sec-integerindexedobjectcreate' + }, + InternalizeJSONProperty: { + url: 'https://262.ecma-international.org/10.0/#sec-internalizejsonproperty' + }, + Invoke: { + url: 'https://262.ecma-international.org/10.0/#sec-invoke' + }, + IsAccessorDescriptor: { + url: 'https://262.ecma-international.org/10.0/#sec-isaccessordescriptor' + }, + IsAnonymousFunctionDefinition: { + url: 'https://262.ecma-international.org/10.0/#sec-isanonymousfunctiondefinition' + }, + IsArray: { + url: 'https://262.ecma-international.org/10.0/#sec-isarray' + }, + IsCallable: { + url: 'https://262.ecma-international.org/10.0/#sec-iscallable' + }, + IsCompatiblePropertyDescriptor: { + url: 'https://262.ecma-international.org/10.0/#sec-iscompatiblepropertydescriptor' + }, + IsConcatSpreadable: { + url: 'https://262.ecma-international.org/10.0/#sec-isconcatspreadable' + }, + IsConstructor: { + url: 'https://262.ecma-international.org/10.0/#sec-isconstructor' + }, + IsDataDescriptor: { + url: 'https://262.ecma-international.org/10.0/#sec-isdatadescriptor' + }, + IsDetachedBuffer: { + url: 'https://262.ecma-international.org/10.0/#sec-isdetachedbuffer' + }, + IsExtensible: { + url: 'https://262.ecma-international.org/10.0/#sec-isextensible-o' + }, + IsGenericDescriptor: { + url: 'https://262.ecma-international.org/10.0/#sec-isgenericdescriptor' + }, + IsInTailPosition: { + url: 'https://262.ecma-international.org/10.0/#sec-isintailposition' + }, + IsInteger: { + url: 'https://262.ecma-international.org/10.0/#sec-isinteger' + }, + IsLabelledFunction: { + url: 'https://262.ecma-international.org/10.0/#sec-islabelledfunction' + }, + IsPromise: { + url: 'https://262.ecma-international.org/10.0/#sec-ispromise' + }, + IsPropertyKey: { + url: 'https://262.ecma-international.org/10.0/#sec-ispropertykey' + }, + IsPropertyReference: { + url: 'https://262.ecma-international.org/10.0/#sec-ispropertyreference' + }, + IsRegExp: { + url: 'https://262.ecma-international.org/10.0/#sec-isregexp' + }, + IsSharedArrayBuffer: { + url: 'https://262.ecma-international.org/10.0/#sec-issharedarraybuffer' + }, + IsStrictReference: { + url: 'https://262.ecma-international.org/10.0/#sec-isstrictreference' + }, + IsStringPrefix: { + url: 'https://262.ecma-international.org/10.0/#sec-isstringprefix' + }, + IsSuperReference: { + url: 'https://262.ecma-international.org/10.0/#sec-issuperreference' + }, + IsUnresolvableReference: { + url: 'https://262.ecma-international.org/10.0/#sec-isunresolvablereference' + }, + IsWordChar: { + url: 'https://262.ecma-international.org/10.0/#sec-runtime-semantics-iswordchar-abstract-operation' + }, + IterableToList: { + url: 'https://262.ecma-international.org/10.0/#sec-iterabletolist' + }, + IteratorClose: { + url: 'https://262.ecma-international.org/10.0/#sec-iteratorclose' + }, + IteratorComplete: { + url: 'https://262.ecma-international.org/10.0/#sec-iteratorcomplete' + }, + IteratorNext: { + url: 'https://262.ecma-international.org/10.0/#sec-iteratornext' + }, + IteratorStep: { + url: 'https://262.ecma-international.org/10.0/#sec-iteratorstep' + }, + IteratorValue: { + url: 'https://262.ecma-international.org/10.0/#sec-iteratorvalue' + }, + LeaveCriticalSection: { + url: 'https://262.ecma-international.org/10.0/#sec-leavecriticalsection' + }, + LocalTime: { + url: 'https://262.ecma-international.org/10.0/#sec-localtime' + }, + LoopContinues: { + url: 'https://262.ecma-international.org/10.0/#sec-loopcontinues' + }, + MakeArgGetter: { + url: 'https://262.ecma-international.org/10.0/#sec-makearggetter' + }, + MakeArgSetter: { + url: 'https://262.ecma-international.org/10.0/#sec-makeargsetter' + }, + MakeClassConstructor: { + url: 'https://262.ecma-international.org/10.0/#sec-makeclassconstructor' + }, + MakeConstructor: { + url: 'https://262.ecma-international.org/10.0/#sec-makeconstructor' + }, + MakeDate: { + url: 'https://262.ecma-international.org/10.0/#sec-makedate' + }, + MakeDay: { + url: 'https://262.ecma-international.org/10.0/#sec-makeday' + }, + MakeMethod: { + url: 'https://262.ecma-international.org/10.0/#sec-makemethod' + }, + MakeSuperPropertyReference: { + url: 'https://262.ecma-international.org/10.0/#sec-makesuperpropertyreference' + }, + MakeTime: { + url: 'https://262.ecma-international.org/10.0/#sec-maketime' + }, + max: { + url: 'https://262.ecma-international.org/10.0/#eqn-max' + }, + 'memory-order': { + url: 'https://262.ecma-international.org/10.0/#sec-memory-order' + }, + min: { + url: 'https://262.ecma-international.org/10.0/#eqn-min' + }, + MinFromTime: { + url: 'https://262.ecma-international.org/10.0/#eqn-MinFromTime' + }, + ModuleNamespaceCreate: { + url: 'https://262.ecma-international.org/10.0/#sec-modulenamespacecreate' + }, + modulo: { + url: 'https://262.ecma-international.org/10.0/#eqn-modulo' + }, + MonthFromTime: { + url: 'https://262.ecma-international.org/10.0/#eqn-MonthFromTime' + }, + msFromTime: { + url: 'https://262.ecma-international.org/10.0/#eqn-msFromTime' + }, + NewDeclarativeEnvironment: { + url: 'https://262.ecma-international.org/10.0/#sec-newdeclarativeenvironment' + }, + NewFunctionEnvironment: { + url: 'https://262.ecma-international.org/10.0/#sec-newfunctionenvironment' + }, + NewGlobalEnvironment: { + url: 'https://262.ecma-international.org/10.0/#sec-newglobalenvironment' + }, + NewModuleEnvironment: { + url: 'https://262.ecma-international.org/10.0/#sec-newmoduleenvironment' + }, + NewObjectEnvironment: { + url: 'https://262.ecma-international.org/10.0/#sec-newobjectenvironment' + }, + NewPromiseCapability: { + url: 'https://262.ecma-international.org/10.0/#sec-newpromisecapability' + }, + NormalCompletion: { + url: 'https://262.ecma-international.org/10.0/#sec-normalcompletion' + }, + NotifyWaiter: { + url: 'https://262.ecma-international.org/10.0/#sec-notifywaiter' + }, + NumberToRawBytes: { + url: 'https://262.ecma-international.org/10.0/#sec-numbertorawbytes' + }, + NumberToString: { + url: 'https://262.ecma-international.org/10.0/#sec-tostring-applied-to-the-number-type' + }, + ObjectCreate: { + url: 'https://262.ecma-international.org/10.0/#sec-objectcreate' + }, + ObjectDefineProperties: { + url: 'https://262.ecma-international.org/10.0/#sec-objectdefineproperties' + }, + OrdinaryCallBindThis: { + url: 'https://262.ecma-international.org/10.0/#sec-ordinarycallbindthis' + }, + OrdinaryCallEvaluateBody: { + url: 'https://262.ecma-international.org/10.0/#sec-ordinarycallevaluatebody' + }, + OrdinaryCreateFromConstructor: { + url: 'https://262.ecma-international.org/10.0/#sec-ordinarycreatefromconstructor' + }, + OrdinaryDefineOwnProperty: { + url: 'https://262.ecma-international.org/10.0/#sec-ordinarydefineownproperty' + }, + OrdinaryDelete: { + url: 'https://262.ecma-international.org/10.0/#sec-ordinarydelete' + }, + OrdinaryGet: { + url: 'https://262.ecma-international.org/10.0/#sec-ordinaryget' + }, + OrdinaryGetOwnProperty: { + url: 'https://262.ecma-international.org/10.0/#sec-ordinarygetownproperty' + }, + OrdinaryGetPrototypeOf: { + url: 'https://262.ecma-international.org/10.0/#sec-ordinarygetprototypeof' + }, + OrdinaryHasInstance: { + url: 'https://262.ecma-international.org/10.0/#sec-ordinaryhasinstance' + }, + OrdinaryHasProperty: { + url: 'https://262.ecma-international.org/10.0/#sec-ordinaryhasproperty' + }, + OrdinaryIsExtensible: { + url: 'https://262.ecma-international.org/10.0/#sec-ordinaryisextensible' + }, + OrdinaryOwnPropertyKeys: { + url: 'https://262.ecma-international.org/10.0/#sec-ordinaryownpropertykeys' + }, + OrdinaryPreventExtensions: { + url: 'https://262.ecma-international.org/10.0/#sec-ordinarypreventextensions' + }, + OrdinarySet: { + url: 'https://262.ecma-international.org/10.0/#sec-ordinaryset' + }, + OrdinarySetPrototypeOf: { + url: 'https://262.ecma-international.org/10.0/#sec-ordinarysetprototypeof' + }, + OrdinarySetWithOwnDescriptor: { + url: 'https://262.ecma-international.org/10.0/#sec-ordinarysetwithowndescriptor' + }, + OrdinaryToPrimitive: { + url: 'https://262.ecma-international.org/10.0/#sec-ordinarytoprimitive' + }, + ParseModule: { + url: 'https://262.ecma-international.org/10.0/#sec-parsemodule' + }, + ParseScript: { + url: 'https://262.ecma-international.org/10.0/#sec-parse-script' + }, + PerformEval: { + url: 'https://262.ecma-international.org/10.0/#sec-performeval' + }, + PerformPromiseAll: { + url: 'https://262.ecma-international.org/10.0/#sec-performpromiseall' + }, + PerformPromiseRace: { + url: 'https://262.ecma-international.org/10.0/#sec-performpromiserace' + }, + PerformPromiseThen: { + url: 'https://262.ecma-international.org/10.0/#sec-performpromisethen' + }, + PrepareForOrdinaryCall: { + url: 'https://262.ecma-international.org/10.0/#sec-prepareforordinarycall' + }, + PrepareForTailCall: { + url: 'https://262.ecma-international.org/10.0/#sec-preparefortailcall' + }, + PromiseReactionJob: { + url: 'https://262.ecma-international.org/10.0/#sec-promisereactionjob' + }, + PromiseResolve: { + url: 'https://262.ecma-international.org/10.0/#sec-promise-resolve' + }, + PromiseResolveThenableJob: { + url: 'https://262.ecma-international.org/10.0/#sec-promiseresolvethenablejob' + }, + ProxyCreate: { + url: 'https://262.ecma-international.org/10.0/#sec-proxycreate' + }, + PutValue: { + url: 'https://262.ecma-international.org/10.0/#sec-putvalue' + }, + QuoteJSONString: { + url: 'https://262.ecma-international.org/10.0/#sec-quotejsonstring' + }, + RawBytesToNumber: { + url: 'https://262.ecma-international.org/10.0/#sec-rawbytestonumber' + }, + 'reads-bytes-from': { + url: 'https://262.ecma-international.org/10.0/#sec-reads-bytes-from' + }, + 'reads-from': { + url: 'https://262.ecma-international.org/10.0/#sec-reads-from' + }, + RegExpAlloc: { + url: 'https://262.ecma-international.org/10.0/#sec-regexpalloc' + }, + RegExpBuiltinExec: { + url: 'https://262.ecma-international.org/10.0/#sec-regexpbuiltinexec' + }, + RegExpCreate: { + url: 'https://262.ecma-international.org/10.0/#sec-regexpcreate' + }, + RegExpExec: { + url: 'https://262.ecma-international.org/10.0/#sec-regexpexec' + }, + RegExpInitialize: { + url: 'https://262.ecma-international.org/10.0/#sec-regexpinitialize' + }, + RejectPromise: { + url: 'https://262.ecma-international.org/10.0/#sec-rejectpromise' + }, + RemoveWaiter: { + url: 'https://262.ecma-international.org/10.0/#sec-removewaiter' + }, + RemoveWaiters: { + url: 'https://262.ecma-international.org/10.0/#sec-removewaiters' + }, + RepeatMatcher: { + url: 'https://262.ecma-international.org/10.0/#sec-runtime-semantics-repeatmatcher-abstract-operation' + }, + RequireObjectCoercible: { + url: 'https://262.ecma-international.org/10.0/#sec-requireobjectcoercible' + }, + ResolveBinding: { + url: 'https://262.ecma-international.org/10.0/#sec-resolvebinding' + }, + ResolveThisBinding: { + url: 'https://262.ecma-international.org/10.0/#sec-resolvethisbinding' + }, + ReturnIfAbrupt: { + url: 'https://262.ecma-international.org/10.0/#sec-returnifabrupt' + }, + RunJobs: { + url: 'https://262.ecma-international.org/10.0/#sec-runjobs' + }, + SameValue: { + url: 'https://262.ecma-international.org/10.0/#sec-samevalue' + }, + SameValueNonNumber: { + url: 'https://262.ecma-international.org/10.0/#sec-samevaluenonnumber' + }, + SameValueZero: { + url: 'https://262.ecma-international.org/10.0/#sec-samevaluezero' + }, + ScriptEvaluation: { + url: 'https://262.ecma-international.org/10.0/#sec-runtime-semantics-scriptevaluation' + }, + ScriptEvaluationJob: { + url: 'https://262.ecma-international.org/10.0/#sec-scriptevaluationjob' + }, + SecFromTime: { + url: 'https://262.ecma-international.org/10.0/#eqn-SecFromTime' + }, + SerializeJSONArray: { + url: 'https://262.ecma-international.org/10.0/#sec-serializejsonarray' + }, + SerializeJSONObject: { + url: 'https://262.ecma-international.org/10.0/#sec-serializejsonobject' + }, + SerializeJSONProperty: { + url: 'https://262.ecma-international.org/10.0/#sec-serializejsonproperty' + }, + Set: { + url: 'https://262.ecma-international.org/10.0/#sec-set-o-p-v-throw' + }, + SetDefaultGlobalBindings: { + url: 'https://262.ecma-international.org/10.0/#sec-setdefaultglobalbindings' + }, + SetFunctionLength: { + url: 'https://262.ecma-international.org/10.0/#sec-setfunctionlength' + }, + SetFunctionName: { + url: 'https://262.ecma-international.org/10.0/#sec-setfunctionname' + }, + SetImmutablePrototype: { + url: 'https://262.ecma-international.org/10.0/#sec-set-immutable-prototype' + }, + SetIntegrityLevel: { + url: 'https://262.ecma-international.org/10.0/#sec-setintegritylevel' + }, + SetRealmGlobalObject: { + url: 'https://262.ecma-international.org/10.0/#sec-setrealmglobalobject' + }, + SetValueInBuffer: { + url: 'https://262.ecma-international.org/10.0/#sec-setvalueinbuffer' + }, + SetViewValue: { + url: 'https://262.ecma-international.org/10.0/#sec-setviewvalue' + }, + SharedDataBlockEventSet: { + url: 'https://262.ecma-international.org/10.0/#sec-sharedatablockeventset' + }, + SortCompare: { + url: 'https://262.ecma-international.org/10.0/#sec-sortcompare' + }, + SpeciesConstructor: { + url: 'https://262.ecma-international.org/10.0/#sec-speciesconstructor' + }, + SplitMatch: { + url: 'https://262.ecma-international.org/10.0/#sec-splitmatch' + }, + 'Strict Equality Comparison': { + url: 'https://262.ecma-international.org/10.0/#sec-strict-equality-comparison' + }, + StringCreate: { + url: 'https://262.ecma-international.org/10.0/#sec-stringcreate' + }, + StringGetOwnProperty: { + url: 'https://262.ecma-international.org/10.0/#sec-stringgetownproperty' + }, + Suspend: { + url: 'https://262.ecma-international.org/10.0/#sec-suspend' + }, + SymbolDescriptiveString: { + url: 'https://262.ecma-international.org/10.0/#sec-symboldescriptivestring' + }, + SynchronizeEventSet: { + url: 'https://262.ecma-international.org/10.0/#sec-synchronizeeventset' + }, + 'synchronizes-with': { + url: 'https://262.ecma-international.org/10.0/#sec-synchronizes-with' + }, + TestIntegrityLevel: { + url: 'https://262.ecma-international.org/10.0/#sec-testintegritylevel' + }, + thisBooleanValue: { + url: 'https://262.ecma-international.org/10.0/#sec-thisbooleanvalue' + }, + thisNumberValue: { + url: 'https://262.ecma-international.org/10.0/#sec-thisnumbervalue' + }, + thisStringValue: { + url: 'https://262.ecma-international.org/10.0/#sec-thisstringvalue' + }, + thisSymbolValue: { + url: 'https://262.ecma-international.org/10.0/#sec-thissymbolvalue' + }, + thisTimeValue: { + url: 'https://262.ecma-international.org/10.0/#sec-thistimevalue' + }, + ThrowCompletion: { + url: 'https://262.ecma-international.org/10.0/#sec-throwcompletion' + }, + TimeClip: { + url: 'https://262.ecma-international.org/10.0/#sec-timeclip' + }, + TimeFromYear: { + url: 'https://262.ecma-international.org/10.0/#eqn-TimeFromYear' + }, + TimeString: { + url: 'https://262.ecma-international.org/10.0/#sec-timestring' + }, + TimeWithinDay: { + url: 'https://262.ecma-international.org/10.0/#eqn-TimeWithinDay' + }, + TimeZoneString: { + url: 'https://262.ecma-international.org/10.0/#sec-timezoneestring' + }, + ToBoolean: { + url: 'https://262.ecma-international.org/10.0/#sec-toboolean' + }, + ToDateString: { + url: 'https://262.ecma-international.org/10.0/#sec-todatestring' + }, + ToIndex: { + url: 'https://262.ecma-international.org/10.0/#sec-toindex' + }, + ToInt16: { + url: 'https://262.ecma-international.org/10.0/#sec-toint16' + }, + ToInt32: { + url: 'https://262.ecma-international.org/10.0/#sec-toint32' + }, + ToInt8: { + url: 'https://262.ecma-international.org/10.0/#sec-toint8' + }, + ToInteger: { + url: 'https://262.ecma-international.org/10.0/#sec-tointeger' + }, + ToLength: { + url: 'https://262.ecma-international.org/10.0/#sec-tolength' + }, + ToNumber: { + url: 'https://262.ecma-international.org/10.0/#sec-tonumber' + }, + ToObject: { + url: 'https://262.ecma-international.org/10.0/#sec-toobject' + }, + TopLevelModuleEvaluationJob: { + url: 'https://262.ecma-international.org/10.0/#sec-toplevelmoduleevaluationjob' + }, + ToPrimitive: { + url: 'https://262.ecma-international.org/10.0/#sec-toprimitive' + }, + ToPropertyDescriptor: { + url: 'https://262.ecma-international.org/10.0/#sec-topropertydescriptor' + }, + ToPropertyKey: { + url: 'https://262.ecma-international.org/10.0/#sec-topropertykey' + }, + ToString: { + url: 'https://262.ecma-international.org/10.0/#sec-tostring' + }, + ToUint16: { + url: 'https://262.ecma-international.org/10.0/#sec-touint16' + }, + ToUint32: { + url: 'https://262.ecma-international.org/10.0/#sec-touint32' + }, + ToUint8: { + url: 'https://262.ecma-international.org/10.0/#sec-touint8' + }, + ToUint8Clamp: { + url: 'https://262.ecma-international.org/10.0/#sec-touint8clamp' + }, + TriggerPromiseReactions: { + url: 'https://262.ecma-international.org/10.0/#sec-triggerpromisereactions' + }, + TrimString: { + url: 'https://262.ecma-international.org/10.0/#sec-trimstring' + }, + Type: { + url: 'https://262.ecma-international.org/10.0/#sec-ecmascript-data-types-and-values' + }, + TypedArrayCreate: { + url: 'https://262.ecma-international.org/10.0/#typedarray-create' + }, + TypedArraySpeciesCreate: { + url: 'https://262.ecma-international.org/10.0/#typedarray-species-create' + }, + UnicodeEscape: { + url: 'https://262.ecma-international.org/10.0/#sec-unicodeescape' + }, + UnicodeMatchProperty: { + url: 'https://262.ecma-international.org/10.0/#sec-runtime-semantics-unicodematchproperty-p' + }, + UnicodeMatchPropertyValue: { + url: 'https://262.ecma-international.org/10.0/#sec-runtime-semantics-unicodematchpropertyvalue-p-v' + }, + UpdateEmpty: { + url: 'https://262.ecma-international.org/10.0/#sec-updateempty' + }, + UTC: { + url: 'https://262.ecma-international.org/10.0/#sec-utc-t' + }, + UTF16Decode: { + url: 'https://262.ecma-international.org/10.0/#sec-utf16decode' + }, + UTF16Encoding: { + url: 'https://262.ecma-international.org/10.0/#sec-utf16encoding' + }, + ValidateAndApplyPropertyDescriptor: { + url: 'https://262.ecma-international.org/10.0/#sec-validateandapplypropertydescriptor' + }, + ValidateAtomicAccess: { + url: 'https://262.ecma-international.org/10.0/#sec-validateatomicaccess' + }, + ValidateSharedIntegerTypedArray: { + url: 'https://262.ecma-international.org/10.0/#sec-validatesharedintegertypedarray' + }, + ValidateTypedArray: { + url: 'https://262.ecma-international.org/10.0/#sec-validatetypedarray' + }, + ValueOfReadEvent: { + url: 'https://262.ecma-international.org/10.0/#sec-valueofreadevent' + }, + WeekDay: { + url: 'https://262.ecma-international.org/10.0/#sec-week-day' + }, + WordCharacters: { + url: 'https://262.ecma-international.org/10.0/#sec-runtime-semantics-wordcharacters-abstract-operation' + }, + YearFromTime: { + url: 'https://262.ecma-international.org/10.0/#eqn-YearFromTime' + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2020.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2020.js new file mode 100644 index 0000000000000000000000000000000000000000..1e448539f245faf0fcfa7ea5e7d5b657b02ae438 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2020.js @@ -0,0 +1,1228 @@ +'use strict'; + +module.exports = { + abs: { + url: 'https://262.ecma-international.org/11.0/#eqn-abs' + }, + 'Abstract Equality Comparison': { + url: 'https://262.ecma-international.org/11.0/#sec-abstract-equality-comparison' + }, + 'Abstract Relational Comparison': { + url: 'https://262.ecma-international.org/11.0/#sec-abstract-relational-comparison' + }, + AddEntriesFromIterable: { + url: 'https://262.ecma-international.org/11.0/#sec-add-entries-from-iterable' + }, + AddRestrictedFunctionProperties: { + url: 'https://262.ecma-international.org/11.0/#sec-addrestrictedfunctionproperties' + }, + AddWaiter: { + url: 'https://262.ecma-international.org/11.0/#sec-addwaiter' + }, + AdvanceStringIndex: { + url: 'https://262.ecma-international.org/11.0/#sec-advancestringindex' + }, + 'agent-order': { + url: 'https://262.ecma-international.org/11.0/#sec-agent-order' + }, + AgentCanSuspend: { + url: 'https://262.ecma-international.org/11.0/#sec-agentcansuspend' + }, + AgentSignifier: { + url: 'https://262.ecma-international.org/11.0/#sec-agentsignifier' + }, + AllocateArrayBuffer: { + url: 'https://262.ecma-international.org/11.0/#sec-allocatearraybuffer' + }, + AllocateSharedArrayBuffer: { + url: 'https://262.ecma-international.org/11.0/#sec-allocatesharedarraybuffer' + }, + AllocateTypedArray: { + url: 'https://262.ecma-international.org/11.0/#sec-allocatetypedarray' + }, + AllocateTypedArrayBuffer: { + url: 'https://262.ecma-international.org/11.0/#sec-allocatetypedarraybuffer' + }, + ArrayCreate: { + url: 'https://262.ecma-international.org/11.0/#sec-arraycreate' + }, + ArraySetLength: { + url: 'https://262.ecma-international.org/11.0/#sec-arraysetlength' + }, + ArraySpeciesCreate: { + url: 'https://262.ecma-international.org/11.0/#sec-arrayspeciescreate' + }, + AsyncFromSyncIteratorContinuation: { + url: 'https://262.ecma-international.org/11.0/#sec-asyncfromsynciteratorcontinuation' + }, + AsyncFunctionStart: { + url: 'https://262.ecma-international.org/11.0/#sec-async-functions-abstract-operations-async-function-start' + }, + AsyncGeneratorEnqueue: { + url: 'https://262.ecma-international.org/11.0/#sec-asyncgeneratorenqueue' + }, + AsyncGeneratorReject: { + url: 'https://262.ecma-international.org/11.0/#sec-asyncgeneratorreject' + }, + AsyncGeneratorResolve: { + url: 'https://262.ecma-international.org/11.0/#sec-asyncgeneratorresolve' + }, + AsyncGeneratorResumeNext: { + url: 'https://262.ecma-international.org/11.0/#sec-asyncgeneratorresumenext' + }, + AsyncGeneratorStart: { + url: 'https://262.ecma-international.org/11.0/#sec-asyncgeneratorstart' + }, + AsyncGeneratorYield: { + url: 'https://262.ecma-international.org/11.0/#sec-asyncgeneratoryield' + }, + AsyncIteratorClose: { + url: 'https://262.ecma-international.org/11.0/#sec-asynciteratorclose' + }, + AtomicLoad: { + url: 'https://262.ecma-international.org/11.0/#sec-atomicload' + }, + AtomicReadModifyWrite: { + url: 'https://262.ecma-international.org/11.0/#sec-atomicreadmodifywrite' + }, + Await: { + url: 'https://262.ecma-international.org/11.0/#await' + }, + BackreferenceMatcher: { + url: 'https://262.ecma-international.org/11.0/#sec-backreference-matcher' + }, + 'BigInt::add': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-add' + }, + 'BigInt::bitwiseAND': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-bitwiseAND' + }, + 'BigInt::bitwiseNOT': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-bitwiseNOT' + }, + 'BigInt::bitwiseOR': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-bitwiseOR' + }, + 'BigInt::bitwiseXOR': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-bitwiseXOR' + }, + 'BigInt::divide': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-divide' + }, + 'BigInt::equal': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-equal' + }, + 'BigInt::exponentiate': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-exponentiate' + }, + 'BigInt::leftShift': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-leftShift' + }, + 'BigInt::lessThan': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-lessThan' + }, + 'BigInt::multiply': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-multiply' + }, + 'BigInt::remainder': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-remainder' + }, + 'BigInt::sameValue': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-sameValue' + }, + 'BigInt::sameValueZero': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-sameValueZero' + }, + 'BigInt::signedRightShift': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-signedRightShift' + }, + 'BigInt::subtract': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-subtract' + }, + 'BigInt::toString': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-tostring' + }, + 'BigInt::unaryMinus': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-unaryMinus' + }, + 'BigInt::unsignedRightShift': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-unsignedRightShift' + }, + BigIntBitwiseOp: { + url: 'https://262.ecma-international.org/11.0/#sec-bigintbitwiseop' + }, + BinaryAnd: { + url: 'https://262.ecma-international.org/11.0/#sec-binaryand' + }, + BinaryOr: { + url: 'https://262.ecma-international.org/11.0/#sec-binaryor' + }, + BinaryXor: { + url: 'https://262.ecma-international.org/11.0/#sec-binaryxor' + }, + BlockDeclarationInstantiation: { + url: 'https://262.ecma-international.org/11.0/#sec-blockdeclarationinstantiation' + }, + BoundFunctionCreate: { + url: 'https://262.ecma-international.org/11.0/#sec-boundfunctioncreate' + }, + Call: { + url: 'https://262.ecma-international.org/11.0/#sec-call' + }, + Canonicalize: { + url: 'https://262.ecma-international.org/11.0/#sec-runtime-semantics-canonicalize-ch' + }, + CanonicalNumericIndexString: { + url: 'https://262.ecma-international.org/11.0/#sec-canonicalnumericindexstring' + }, + CaseClauseIsSelected: { + url: 'https://262.ecma-international.org/11.0/#sec-runtime-semantics-caseclauseisselected' + }, + CharacterRange: { + url: 'https://262.ecma-international.org/11.0/#sec-runtime-semantics-characterrange-abstract-operation' + }, + CharacterRangeOrUnion: { + url: 'https://262.ecma-international.org/11.0/#sec-runtime-semantics-characterrangeorunion-abstract-operation' + }, + CharacterSetMatcher: { + url: 'https://262.ecma-international.org/11.0/#sec-runtime-semantics-charactersetmatcher-abstract-operation' + }, + CloneArrayBuffer: { + url: 'https://262.ecma-international.org/11.0/#sec-clonearraybuffer' + }, + CodePointAt: { + url: 'https://262.ecma-international.org/11.0/#sec-codepointat' + }, + CompletePropertyDescriptor: { + url: 'https://262.ecma-international.org/11.0/#sec-completepropertydescriptor' + }, + Completion: { + url: 'https://262.ecma-international.org/11.0/#sec-completion-record-specification-type' + }, + CompletionRecord: { + url: 'https://262.ecma-international.org/11.0/#sec-completion-record-specification-type' + }, + ComposeWriteEventBytes: { + url: 'https://262.ecma-international.org/11.0/#sec-composewriteeventbytes' + }, + Construct: { + url: 'https://262.ecma-international.org/11.0/#sec-construct' + }, + CopyDataBlockBytes: { + url: 'https://262.ecma-international.org/11.0/#sec-copydatablockbytes' + }, + CopyDataProperties: { + url: 'https://262.ecma-international.org/11.0/#sec-copydataproperties' + }, + CreateArrayFromList: { + url: 'https://262.ecma-international.org/11.0/#sec-createarrayfromlist' + }, + CreateArrayIterator: { + url: 'https://262.ecma-international.org/11.0/#sec-createarrayiterator' + }, + CreateAsyncFromSyncIterator: { + url: 'https://262.ecma-international.org/11.0/#sec-createasyncfromsynciterator' + }, + CreateBuiltinFunction: { + url: 'https://262.ecma-international.org/11.0/#sec-createbuiltinfunction' + }, + CreateByteDataBlock: { + url: 'https://262.ecma-international.org/11.0/#sec-createbytedatablock' + }, + CreateDataProperty: { + url: 'https://262.ecma-international.org/11.0/#sec-createdataproperty' + }, + CreateDataPropertyOrThrow: { + url: 'https://262.ecma-international.org/11.0/#sec-createdatapropertyorthrow' + }, + CreateDynamicFunction: { + url: 'https://262.ecma-international.org/11.0/#sec-createdynamicfunction' + }, + CreateForInIterator: { + url: 'https://262.ecma-international.org/11.0/#sec-createforiniterator' + }, + CreateHTML: { + url: 'https://262.ecma-international.org/11.0/#sec-createhtml' + }, + CreateIntrinsics: { + url: 'https://262.ecma-international.org/11.0/#sec-createintrinsics' + }, + CreateIterResultObject: { + url: 'https://262.ecma-international.org/11.0/#sec-createiterresultobject' + }, + CreateListFromArrayLike: { + url: 'https://262.ecma-international.org/11.0/#sec-createlistfromarraylike' + }, + CreateListIteratorRecord: { + url: 'https://262.ecma-international.org/11.0/#sec-createlistiteratorRecord' + }, + CreateMapIterator: { + url: 'https://262.ecma-international.org/11.0/#sec-createmapiterator' + }, + CreateMappedArgumentsObject: { + url: 'https://262.ecma-international.org/11.0/#sec-createmappedargumentsobject' + }, + CreateMethodProperty: { + url: 'https://262.ecma-international.org/11.0/#sec-createmethodproperty' + }, + CreatePerIterationEnvironment: { + url: 'https://262.ecma-international.org/11.0/#sec-createperiterationenvironment' + }, + CreateRealm: { + url: 'https://262.ecma-international.org/11.0/#sec-createrealm' + }, + CreateRegExpStringIterator: { + url: 'https://262.ecma-international.org/11.0/#sec-createregexpstringiterator' + }, + CreateResolvingFunctions: { + url: 'https://262.ecma-international.org/11.0/#sec-createresolvingfunctions' + }, + CreateSetIterator: { + url: 'https://262.ecma-international.org/11.0/#sec-createsetiterator' + }, + CreateSharedByteDataBlock: { + url: 'https://262.ecma-international.org/11.0/#sec-createsharedbytedatablock' + }, + CreateStringIterator: { + url: 'https://262.ecma-international.org/11.0/#sec-createstringiterator' + }, + CreateUnmappedArgumentsObject: { + url: 'https://262.ecma-international.org/11.0/#sec-createunmappedargumentsobject' + }, + DateFromTime: { + url: 'https://262.ecma-international.org/11.0/#sec-date-number' + }, + DateString: { + url: 'https://262.ecma-international.org/11.0/#sec-datestring' + }, + Day: { + url: 'https://262.ecma-international.org/11.0/#eqn-Day' + }, + DayFromYear: { + url: 'https://262.ecma-international.org/11.0/#eqn-DaysFromYear' + }, + DaysInYear: { + url: 'https://262.ecma-international.org/11.0/#eqn-DaysInYear' + }, + DayWithinYear: { + url: 'https://262.ecma-international.org/11.0/#eqn-DayWithinYear' + }, + Decode: { + url: 'https://262.ecma-international.org/11.0/#sec-decode' + }, + DefinePropertyOrThrow: { + url: 'https://262.ecma-international.org/11.0/#sec-definepropertyorthrow' + }, + DeletePropertyOrThrow: { + url: 'https://262.ecma-international.org/11.0/#sec-deletepropertyorthrow' + }, + DetachArrayBuffer: { + url: 'https://262.ecma-international.org/11.0/#sec-detacharraybuffer' + }, + Encode: { + url: 'https://262.ecma-international.org/11.0/#sec-encode' + }, + EnterCriticalSection: { + url: 'https://262.ecma-international.org/11.0/#sec-entercriticalsection' + }, + EnumerableOwnPropertyNames: { + url: 'https://262.ecma-international.org/11.0/#sec-enumerableownpropertynames' + }, + EnumerateObjectProperties: { + url: 'https://262.ecma-international.org/11.0/#sec-enumerate-object-properties' + }, + EscapeRegExpPattern: { + url: 'https://262.ecma-international.org/11.0/#sec-escaperegexppattern' + }, + EvalDeclarationInstantiation: { + url: 'https://262.ecma-international.org/11.0/#sec-evaldeclarationinstantiation' + }, + EvaluateCall: { + url: 'https://262.ecma-international.org/11.0/#sec-evaluatecall' + }, + EvaluateNew: { + url: 'https://262.ecma-international.org/11.0/#sec-evaluatenew' + }, + EvaluatePropertyAccessWithExpressionKey: { + url: 'https://262.ecma-international.org/11.0/#sec-evaluate-property-access-with-expression-key' + }, + EvaluatePropertyAccessWithIdentifierKey: { + url: 'https://262.ecma-international.org/11.0/#sec-evaluate-property-access-with-identifier-key' + }, + EventSet: { + url: 'https://262.ecma-international.org/11.0/#sec-event-set' + }, + ExecuteModule: { + url: 'https://262.ecma-international.org/11.0/#sec-source-text-module-record-execute-module' + }, + FinishDynamicImport: { + url: 'https://262.ecma-international.org/11.0/#sec-finishdynamicimport' + }, + FlattenIntoArray: { + url: 'https://262.ecma-international.org/11.0/#sec-flattenintoarray' + }, + floor: { + url: 'https://262.ecma-international.org/11.0/#eqn-floor' + }, + ForBodyEvaluation: { + url: 'https://262.ecma-international.org/11.0/#sec-forbodyevaluation' + }, + 'ForIn/OfBodyEvaluation': { + url: 'https://262.ecma-international.org/11.0/#sec-runtime-semantics-forin-div-ofbodyevaluation-lhs-stmt-iterator-lhskind-labelset' + }, + 'ForIn/OfHeadEvaluation': { + url: 'https://262.ecma-international.org/11.0/#sec-runtime-semantics-forinofheadevaluation' + }, + FromPropertyDescriptor: { + url: 'https://262.ecma-international.org/11.0/#sec-frompropertydescriptor' + }, + FulfillPromise: { + url: 'https://262.ecma-international.org/11.0/#sec-fulfillpromise' + }, + FunctionDeclarationInstantiation: { + url: 'https://262.ecma-international.org/11.0/#sec-functiondeclarationinstantiation' + }, + GeneratorResume: { + url: 'https://262.ecma-international.org/11.0/#sec-generatorresume' + }, + GeneratorResumeAbrupt: { + url: 'https://262.ecma-international.org/11.0/#sec-generatorresumeabrupt' + }, + GeneratorStart: { + url: 'https://262.ecma-international.org/11.0/#sec-generatorstart' + }, + GeneratorValidate: { + url: 'https://262.ecma-international.org/11.0/#sec-generatorvalidate' + }, + GeneratorYield: { + url: 'https://262.ecma-international.org/11.0/#sec-generatoryield' + }, + Get: { + url: 'https://262.ecma-international.org/11.0/#sec-get-o-p' + }, + GetActiveScriptOrModule: { + url: 'https://262.ecma-international.org/11.0/#sec-getactivescriptormodule' + }, + GetBase: { + url: 'https://262.ecma-international.org/11.0/#sec-getbase' + }, + GetFunctionRealm: { + url: 'https://262.ecma-international.org/11.0/#sec-getfunctionrealm' + }, + GetGeneratorKind: { + url: 'https://262.ecma-international.org/11.0/#sec-getgeneratorkind' + }, + GetGlobalObject: { + url: 'https://262.ecma-international.org/11.0/#sec-getglobalobject' + }, + GetIdentifierReference: { + url: 'https://262.ecma-international.org/11.0/#sec-getidentifierreference' + }, + GetIterator: { + url: 'https://262.ecma-international.org/11.0/#sec-getiterator' + }, + GetMethod: { + url: 'https://262.ecma-international.org/11.0/#sec-getmethod' + }, + GetModifySetValueInBuffer: { + url: 'https://262.ecma-international.org/11.0/#sec-getmodifysetvalueinbuffer' + }, + GetModuleNamespace: { + url: 'https://262.ecma-international.org/11.0/#sec-getmodulenamespace' + }, + GetNewTarget: { + url: 'https://262.ecma-international.org/11.0/#sec-getnewtarget' + }, + GetOwnPropertyKeys: { + url: 'https://262.ecma-international.org/11.0/#sec-getownpropertykeys' + }, + GetPrototypeFromConstructor: { + url: 'https://262.ecma-international.org/11.0/#sec-getprototypefromconstructor' + }, + GetReferencedName: { + url: 'https://262.ecma-international.org/11.0/#sec-getreferencedname' + }, + GetSubstitution: { + url: 'https://262.ecma-international.org/11.0/#sec-getsubstitution' + }, + GetSuperConstructor: { + url: 'https://262.ecma-international.org/11.0/#sec-getsuperconstructor' + }, + GetTemplateObject: { + url: 'https://262.ecma-international.org/11.0/#sec-gettemplateobject' + }, + GetThisEnvironment: { + url: 'https://262.ecma-international.org/11.0/#sec-getthisenvironment' + }, + GetThisValue: { + url: 'https://262.ecma-international.org/11.0/#sec-getthisvalue' + }, + GetV: { + url: 'https://262.ecma-international.org/11.0/#sec-getv' + }, + GetValue: { + url: 'https://262.ecma-international.org/11.0/#sec-getvalue' + }, + GetValueFromBuffer: { + url: 'https://262.ecma-international.org/11.0/#sec-getvaluefrombuffer' + }, + GetViewValue: { + url: 'https://262.ecma-international.org/11.0/#sec-getviewvalue' + }, + GetWaiterList: { + url: 'https://262.ecma-international.org/11.0/#sec-getwaiterlist' + }, + GlobalDeclarationInstantiation: { + url: 'https://262.ecma-international.org/11.0/#sec-globaldeclarationinstantiation' + }, + 'happens-before': { + url: 'https://262.ecma-international.org/11.0/#sec-happens-before' + }, + HasOwnProperty: { + url: 'https://262.ecma-international.org/11.0/#sec-hasownproperty' + }, + HasPrimitiveBase: { + url: 'https://262.ecma-international.org/11.0/#sec-hasprimitivebase' + }, + HasProperty: { + url: 'https://262.ecma-international.org/11.0/#sec-hasproperty' + }, + 'host-synchronizes-with': { + url: 'https://262.ecma-international.org/11.0/#sec-host-synchronizes-with' + }, + HostEventSet: { + url: 'https://262.ecma-international.org/11.0/#sec-hosteventset' + }, + HourFromTime: { + url: 'https://262.ecma-international.org/11.0/#eqn-HourFromTime' + }, + IfAbruptRejectPromise: { + url: 'https://262.ecma-international.org/11.0/#sec-ifabruptrejectpromise' + }, + ImportedLocalNames: { + url: 'https://262.ecma-international.org/11.0/#sec-importedlocalnames' + }, + InitializeBoundName: { + url: 'https://262.ecma-international.org/11.0/#sec-initializeboundname' + }, + InitializeEnvironment: { + url: 'https://262.ecma-international.org/11.0/#sec-source-text-module-record-initialize-environment' + }, + InitializeHostDefinedRealm: { + url: 'https://262.ecma-international.org/11.0/#sec-initializehostdefinedrealm' + }, + InitializeReferencedBinding: { + url: 'https://262.ecma-international.org/11.0/#sec-initializereferencedbinding' + }, + InLeapYear: { + url: 'https://262.ecma-international.org/11.0/#eqn-InLeapYear' + }, + InnerModuleEvaluation: { + url: 'https://262.ecma-international.org/11.0/#sec-innermoduleevaluation' + }, + InnerModuleLinking: { + url: 'https://262.ecma-international.org/11.0/#sec-InnerModuleLinking' + }, + InstanceofOperator: { + url: 'https://262.ecma-international.org/11.0/#sec-instanceofoperator' + }, + IntegerIndexedElementGet: { + url: 'https://262.ecma-international.org/11.0/#sec-integerindexedelementget' + }, + IntegerIndexedElementSet: { + url: 'https://262.ecma-international.org/11.0/#sec-integerindexedelementset' + }, + IntegerIndexedObjectCreate: { + url: 'https://262.ecma-international.org/11.0/#sec-integerindexedobjectcreate' + }, + InternalizeJSONProperty: { + url: 'https://262.ecma-international.org/11.0/#sec-internalizejsonproperty' + }, + Invoke: { + url: 'https://262.ecma-international.org/11.0/#sec-invoke' + }, + IsAccessorDescriptor: { + url: 'https://262.ecma-international.org/11.0/#sec-isaccessordescriptor' + }, + IsAnonymousFunctionDefinition: { + url: 'https://262.ecma-international.org/11.0/#sec-isanonymousfunctiondefinition' + }, + IsArray: { + url: 'https://262.ecma-international.org/11.0/#sec-isarray' + }, + IsBigIntElementType: { + url: 'https://262.ecma-international.org/11.0/#sec-isbigintelementtype' + }, + IsCallable: { + url: 'https://262.ecma-international.org/11.0/#sec-iscallable' + }, + IsCompatiblePropertyDescriptor: { + url: 'https://262.ecma-international.org/11.0/#sec-iscompatiblepropertydescriptor' + }, + IsConcatSpreadable: { + url: 'https://262.ecma-international.org/11.0/#sec-isconcatspreadable' + }, + IsConstructor: { + url: 'https://262.ecma-international.org/11.0/#sec-isconstructor' + }, + IsDataDescriptor: { + url: 'https://262.ecma-international.org/11.0/#sec-isdatadescriptor' + }, + IsDetachedBuffer: { + url: 'https://262.ecma-international.org/11.0/#sec-isdetachedbuffer' + }, + IsExtensible: { + url: 'https://262.ecma-international.org/11.0/#sec-isextensible-o' + }, + IsGenericDescriptor: { + url: 'https://262.ecma-international.org/11.0/#sec-isgenericdescriptor' + }, + IsInTailPosition: { + url: 'https://262.ecma-international.org/11.0/#sec-isintailposition' + }, + IsInteger: { + url: 'https://262.ecma-international.org/11.0/#sec-isinteger' + }, + IsLabelledFunction: { + url: 'https://262.ecma-international.org/11.0/#sec-islabelledfunction' + }, + IsNonNegativeInteger: { + url: 'https://262.ecma-international.org/11.0/#sec-isnonnegativeinteger' + }, + IsNoTearConfiguration: { + url: 'https://262.ecma-international.org/11.0/#sec-isnotearconfiguration' + }, + IsPromise: { + url: 'https://262.ecma-international.org/11.0/#sec-ispromise' + }, + IsPropertyKey: { + url: 'https://262.ecma-international.org/11.0/#sec-ispropertykey' + }, + IsPropertyReference: { + url: 'https://262.ecma-international.org/11.0/#sec-ispropertyreference' + }, + IsRegExp: { + url: 'https://262.ecma-international.org/11.0/#sec-isregexp' + }, + IsSharedArrayBuffer: { + url: 'https://262.ecma-international.org/11.0/#sec-issharedarraybuffer' + }, + IsStrictReference: { + url: 'https://262.ecma-international.org/11.0/#sec-isstrictreference' + }, + IsStringPrefix: { + url: 'https://262.ecma-international.org/11.0/#sec-isstringprefix' + }, + IsSuperReference: { + url: 'https://262.ecma-international.org/11.0/#sec-issuperreference' + }, + IsUnclampedIntegerElementType: { + url: 'https://262.ecma-international.org/11.0/#sec-isunclampedintegerelementtype' + }, + IsUnresolvableReference: { + url: 'https://262.ecma-international.org/11.0/#sec-isunresolvablereference' + }, + IsUnsignedElementType: { + url: 'https://262.ecma-international.org/11.0/#sec-isunsignedelementtype' + }, + IsValidIntegerIndex: { + url: 'https://262.ecma-international.org/11.0/#sec-isvalidintegerindex' + }, + IsValidRegularExpressionLiteral: { + url: 'https://262.ecma-international.org/11.0/#sec-isvalidregularexpressionliteral' + }, + IsWordChar: { + url: 'https://262.ecma-international.org/11.0/#sec-runtime-semantics-iswordchar-abstract-operation' + }, + IterableToList: { + url: 'https://262.ecma-international.org/11.0/#sec-iterabletolist' + }, + IteratorClose: { + url: 'https://262.ecma-international.org/11.0/#sec-iteratorclose' + }, + IteratorComplete: { + url: 'https://262.ecma-international.org/11.0/#sec-iteratorcomplete' + }, + IteratorNext: { + url: 'https://262.ecma-international.org/11.0/#sec-iteratornext' + }, + IteratorStep: { + url: 'https://262.ecma-international.org/11.0/#sec-iteratorstep' + }, + IteratorValue: { + url: 'https://262.ecma-international.org/11.0/#sec-iteratorvalue' + }, + LeaveCriticalSection: { + url: 'https://262.ecma-international.org/11.0/#sec-leavecriticalsection' + }, + LengthOfArrayLike: { + url: 'https://262.ecma-international.org/11.0/#sec-lengthofarraylike' + }, + LocalTime: { + url: 'https://262.ecma-international.org/11.0/#sec-localtime' + }, + LocalTZA: { + url: 'https://262.ecma-international.org/11.0/#sec-local-time-zone-adjustment' + }, + LoopContinues: { + url: 'https://262.ecma-international.org/11.0/#sec-loopcontinues' + }, + MakeArgGetter: { + url: 'https://262.ecma-international.org/11.0/#sec-makearggetter' + }, + MakeArgSetter: { + url: 'https://262.ecma-international.org/11.0/#sec-makeargsetter' + }, + MakeBasicObject: { + url: 'https://262.ecma-international.org/11.0/#sec-makebasicobject' + }, + MakeClassConstructor: { + url: 'https://262.ecma-international.org/11.0/#sec-makeclassconstructor' + }, + MakeConstructor: { + url: 'https://262.ecma-international.org/11.0/#sec-makeconstructor' + }, + MakeDate: { + url: 'https://262.ecma-international.org/11.0/#sec-makedate' + }, + MakeDay: { + url: 'https://262.ecma-international.org/11.0/#sec-makeday' + }, + MakeMethod: { + url: 'https://262.ecma-international.org/11.0/#sec-makemethod' + }, + MakeSuperPropertyReference: { + url: 'https://262.ecma-international.org/11.0/#sec-makesuperpropertyreference' + }, + MakeTime: { + url: 'https://262.ecma-international.org/11.0/#sec-maketime' + }, + max: { + url: 'https://262.ecma-international.org/11.0/#eqn-max' + }, + 'memory-order': { + url: 'https://262.ecma-international.org/11.0/#sec-memory-order' + }, + min: { + url: 'https://262.ecma-international.org/11.0/#eqn-min' + }, + MinFromTime: { + url: 'https://262.ecma-international.org/11.0/#eqn-MinFromTime' + }, + ModuleNamespaceCreate: { + url: 'https://262.ecma-international.org/11.0/#sec-modulenamespacecreate' + }, + modulo: { + url: 'https://262.ecma-international.org/11.0/#eqn-modulo' + }, + MonthFromTime: { + url: 'https://262.ecma-international.org/11.0/#eqn-MonthFromTime' + }, + msFromTime: { + url: 'https://262.ecma-international.org/11.0/#eqn-msFromTime' + }, + NewDeclarativeEnvironment: { + url: 'https://262.ecma-international.org/11.0/#sec-newdeclarativeenvironment' + }, + NewFunctionEnvironment: { + url: 'https://262.ecma-international.org/11.0/#sec-newfunctionenvironment' + }, + NewGlobalEnvironment: { + url: 'https://262.ecma-international.org/11.0/#sec-newglobalenvironment' + }, + NewModuleEnvironment: { + url: 'https://262.ecma-international.org/11.0/#sec-newmoduleenvironment' + }, + NewObjectEnvironment: { + url: 'https://262.ecma-international.org/11.0/#sec-newobjectenvironment' + }, + NewPromiseCapability: { + url: 'https://262.ecma-international.org/11.0/#sec-newpromisecapability' + }, + NewPromiseReactionJob: { + url: 'https://262.ecma-international.org/11.0/#sec-newpromisereactionjob' + }, + NewPromiseResolveThenableJob: { + url: 'https://262.ecma-international.org/11.0/#sec-newpromiseresolvethenablejob' + }, + NormalCompletion: { + url: 'https://262.ecma-international.org/11.0/#sec-normalcompletion' + }, + NotifyWaiter: { + url: 'https://262.ecma-international.org/11.0/#sec-notifywaiter' + }, + 'Number::add': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-number-add' + }, + 'Number::bitwiseAND': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-number-bitwiseAND' + }, + 'Number::bitwiseNOT': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-number-bitwiseNOT' + }, + 'Number::bitwiseOR': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-number-bitwiseOR' + }, + 'Number::bitwiseXOR': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-number-bitwiseXOR' + }, + 'Number::divide': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-number-divide' + }, + 'Number::equal': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-number-equal' + }, + 'Number::exponentiate': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-number-exponentiate' + }, + 'Number::leftShift': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-number-leftShift' + }, + 'Number::lessThan': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-number-lessThan' + }, + 'Number::multiply': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-number-multiply' + }, + 'Number::remainder': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-number-remainder' + }, + 'Number::sameValue': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-number-sameValue' + }, + 'Number::sameValueZero': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-number-sameValueZero' + }, + 'Number::signedRightShift': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-number-signedRightShift' + }, + 'Number::subtract': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-number-subtract' + }, + 'Number::toString': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-number-tostring' + }, + 'Number::unaryMinus': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-number-unaryMinus' + }, + 'Number::unsignedRightShift': { + url: 'https://262.ecma-international.org/11.0/#sec-numeric-types-number-unsignedRightShift' + }, + NumberBitwiseOp: { + url: 'https://262.ecma-international.org/11.0/#sec-numberbitwiseop' + }, + NumberToBigInt: { + url: 'https://262.ecma-international.org/11.0/#sec-numbertobigint' + }, + NumericToRawBytes: { + url: 'https://262.ecma-international.org/11.0/#sec-numerictorawbytes' + }, + ObjectDefineProperties: { + url: 'https://262.ecma-international.org/11.0/#sec-objectdefineproperties' + }, + OrdinaryCallBindThis: { + url: 'https://262.ecma-international.org/11.0/#sec-ordinarycallbindthis' + }, + OrdinaryCallEvaluateBody: { + url: 'https://262.ecma-international.org/11.0/#sec-ordinarycallevaluatebody' + }, + OrdinaryCreateFromConstructor: { + url: 'https://262.ecma-international.org/11.0/#sec-ordinarycreatefromconstructor' + }, + OrdinaryDefineOwnProperty: { + url: 'https://262.ecma-international.org/11.0/#sec-ordinarydefineownproperty' + }, + OrdinaryDelete: { + url: 'https://262.ecma-international.org/11.0/#sec-ordinarydelete' + }, + OrdinaryFunctionCreate: { + url: 'https://262.ecma-international.org/11.0/#sec-ordinaryfunctioncreate' + }, + OrdinaryGet: { + url: 'https://262.ecma-international.org/11.0/#sec-ordinaryget' + }, + OrdinaryGetOwnProperty: { + url: 'https://262.ecma-international.org/11.0/#sec-ordinarygetownproperty' + }, + OrdinaryGetPrototypeOf: { + url: 'https://262.ecma-international.org/11.0/#sec-ordinarygetprototypeof' + }, + OrdinaryHasInstance: { + url: 'https://262.ecma-international.org/11.0/#sec-ordinaryhasinstance' + }, + OrdinaryHasProperty: { + url: 'https://262.ecma-international.org/11.0/#sec-ordinaryhasproperty' + }, + OrdinaryIsExtensible: { + url: 'https://262.ecma-international.org/11.0/#sec-ordinaryisextensible' + }, + OrdinaryObjectCreate: { + url: 'https://262.ecma-international.org/11.0/#sec-ordinaryobjectcreate' + }, + OrdinaryOwnPropertyKeys: { + url: 'https://262.ecma-international.org/11.0/#sec-ordinaryownpropertykeys' + }, + OrdinaryPreventExtensions: { + url: 'https://262.ecma-international.org/11.0/#sec-ordinarypreventextensions' + }, + OrdinarySet: { + url: 'https://262.ecma-international.org/11.0/#sec-ordinaryset' + }, + OrdinarySetPrototypeOf: { + url: 'https://262.ecma-international.org/11.0/#sec-ordinarysetprototypeof' + }, + OrdinarySetWithOwnDescriptor: { + url: 'https://262.ecma-international.org/11.0/#sec-ordinarysetwithowndescriptor' + }, + OrdinaryToPrimitive: { + url: 'https://262.ecma-international.org/11.0/#sec-ordinarytoprimitive' + }, + ParseModule: { + url: 'https://262.ecma-international.org/11.0/#sec-parsemodule' + }, + ParseScript: { + url: 'https://262.ecma-international.org/11.0/#sec-parse-script' + }, + PerformEval: { + url: 'https://262.ecma-international.org/11.0/#sec-performeval' + }, + PerformPromiseAll: { + url: 'https://262.ecma-international.org/11.0/#sec-performpromiseall' + }, + PerformPromiseAllSettled: { + url: 'https://262.ecma-international.org/11.0/#sec-performpromiseallsettled' + }, + PerformPromiseRace: { + url: 'https://262.ecma-international.org/11.0/#sec-performpromiserace' + }, + PerformPromiseThen: { + url: 'https://262.ecma-international.org/11.0/#sec-performpromisethen' + }, + PrepareForOrdinaryCall: { + url: 'https://262.ecma-international.org/11.0/#sec-prepareforordinarycall' + }, + PrepareForTailCall: { + url: 'https://262.ecma-international.org/11.0/#sec-preparefortailcall' + }, + PromiseResolve: { + url: 'https://262.ecma-international.org/11.0/#sec-promise-resolve' + }, + ProxyCreate: { + url: 'https://262.ecma-international.org/11.0/#sec-proxycreate' + }, + PutValue: { + url: 'https://262.ecma-international.org/11.0/#sec-putvalue' + }, + QuoteJSONString: { + url: 'https://262.ecma-international.org/11.0/#sec-quotejsonstring' + }, + RawBytesToNumeric: { + url: 'https://262.ecma-international.org/11.0/#sec-rawbytestonumeric' + }, + 'reads-bytes-from': { + url: 'https://262.ecma-international.org/11.0/#sec-reads-bytes-from' + }, + 'reads-from': { + url: 'https://262.ecma-international.org/11.0/#sec-reads-from' + }, + RegExpAlloc: { + url: 'https://262.ecma-international.org/11.0/#sec-regexpalloc' + }, + RegExpBuiltinExec: { + url: 'https://262.ecma-international.org/11.0/#sec-regexpbuiltinexec' + }, + RegExpCreate: { + url: 'https://262.ecma-international.org/11.0/#sec-regexpcreate' + }, + RegExpExec: { + url: 'https://262.ecma-international.org/11.0/#sec-regexpexec' + }, + RegExpInitialize: { + url: 'https://262.ecma-international.org/11.0/#sec-regexpinitialize' + }, + RejectPromise: { + url: 'https://262.ecma-international.org/11.0/#sec-rejectpromise' + }, + RemoveWaiter: { + url: 'https://262.ecma-international.org/11.0/#sec-removewaiter' + }, + RemoveWaiters: { + url: 'https://262.ecma-international.org/11.0/#sec-removewaiters' + }, + RepeatMatcher: { + url: 'https://262.ecma-international.org/11.0/#sec-runtime-semantics-repeatmatcher-abstract-operation' + }, + RequireInternalSlot: { + url: 'https://262.ecma-international.org/11.0/#sec-requireinternalslot' + }, + RequireObjectCoercible: { + url: 'https://262.ecma-international.org/11.0/#sec-requireobjectcoercible' + }, + ResolveBinding: { + url: 'https://262.ecma-international.org/11.0/#sec-resolvebinding' + }, + ResolveThisBinding: { + url: 'https://262.ecma-international.org/11.0/#sec-resolvethisbinding' + }, + ReturnIfAbrupt: { + url: 'https://262.ecma-international.org/11.0/#sec-returnifabrupt' + }, + SameValue: { + url: 'https://262.ecma-international.org/11.0/#sec-samevalue' + }, + SameValueNonNumeric: { + url: 'https://262.ecma-international.org/11.0/#sec-samevaluenonnumeric' + }, + SameValueZero: { + url: 'https://262.ecma-international.org/11.0/#sec-samevaluezero' + }, + ScriptEvaluation: { + url: 'https://262.ecma-international.org/11.0/#sec-runtime-semantics-scriptevaluation' + }, + SecFromTime: { + url: 'https://262.ecma-international.org/11.0/#eqn-SecFromTime' + }, + SerializeJSONArray: { + url: 'https://262.ecma-international.org/11.0/#sec-serializejsonarray' + }, + SerializeJSONObject: { + url: 'https://262.ecma-international.org/11.0/#sec-serializejsonobject' + }, + SerializeJSONProperty: { + url: 'https://262.ecma-international.org/11.0/#sec-serializejsonproperty' + }, + Set: { + url: 'https://262.ecma-international.org/11.0/#sec-set-o-p-v-throw' + }, + SetDefaultGlobalBindings: { + url: 'https://262.ecma-international.org/11.0/#sec-setdefaultglobalbindings' + }, + SetFunctionLength: { + url: 'https://262.ecma-international.org/11.0/#sec-setfunctionlength' + }, + SetFunctionName: { + url: 'https://262.ecma-international.org/11.0/#sec-setfunctionname' + }, + SetImmutablePrototype: { + url: 'https://262.ecma-international.org/11.0/#sec-set-immutable-prototype' + }, + SetIntegrityLevel: { + url: 'https://262.ecma-international.org/11.0/#sec-setintegritylevel' + }, + SetRealmGlobalObject: { + url: 'https://262.ecma-international.org/11.0/#sec-setrealmglobalobject' + }, + SetValueInBuffer: { + url: 'https://262.ecma-international.org/11.0/#sec-setvalueinbuffer' + }, + SetViewValue: { + url: 'https://262.ecma-international.org/11.0/#sec-setviewvalue' + }, + SharedDataBlockEventSet: { + url: 'https://262.ecma-international.org/11.0/#sec-sharedatablockeventset' + }, + SortCompare: { + url: 'https://262.ecma-international.org/11.0/#sec-sortcompare' + }, + SpeciesConstructor: { + url: 'https://262.ecma-international.org/11.0/#sec-speciesconstructor' + }, + SplitMatch: { + url: 'https://262.ecma-international.org/11.0/#sec-splitmatch' + }, + 'Strict Equality Comparison': { + url: 'https://262.ecma-international.org/11.0/#sec-strict-equality-comparison' + }, + StringCreate: { + url: 'https://262.ecma-international.org/11.0/#sec-stringcreate' + }, + StringGetOwnProperty: { + url: 'https://262.ecma-international.org/11.0/#sec-stringgetownproperty' + }, + StringPad: { + url: 'https://262.ecma-international.org/11.0/#sec-stringpad' + }, + StringToBigInt: { + url: 'https://262.ecma-international.org/11.0/#sec-stringtobigint' + }, + Suspend: { + url: 'https://262.ecma-international.org/11.0/#sec-suspend' + }, + SymbolDescriptiveString: { + url: 'https://262.ecma-international.org/11.0/#sec-symboldescriptivestring' + }, + 'synchronizes-with': { + url: 'https://262.ecma-international.org/11.0/#sec-synchronizes-with' + }, + TestIntegrityLevel: { + url: 'https://262.ecma-international.org/11.0/#sec-testintegritylevel' + }, + thisBigIntValue: { + url: 'https://262.ecma-international.org/11.0/#sec-thisbigintvalue' + }, + thisBooleanValue: { + url: 'https://262.ecma-international.org/11.0/#sec-thisbooleanvalue' + }, + thisNumberValue: { + url: 'https://262.ecma-international.org/11.0/#sec-thisnumbervalue' + }, + thisStringValue: { + url: 'https://262.ecma-international.org/11.0/#sec-thisstringvalue' + }, + thisSymbolValue: { + url: 'https://262.ecma-international.org/11.0/#sec-thissymbolvalue' + }, + thisTimeValue: { + url: 'https://262.ecma-international.org/11.0/#sec-thistimevalue' + }, + ThrowCompletion: { + url: 'https://262.ecma-international.org/11.0/#sec-throwcompletion' + }, + TimeClip: { + url: 'https://262.ecma-international.org/11.0/#sec-timeclip' + }, + TimeFromYear: { + url: 'https://262.ecma-international.org/11.0/#eqn-TimeFromYear' + }, + TimeString: { + url: 'https://262.ecma-international.org/11.0/#sec-timestring' + }, + TimeWithinDay: { + url: 'https://262.ecma-international.org/11.0/#eqn-TimeWithinDay' + }, + TimeZoneString: { + url: 'https://262.ecma-international.org/11.0/#sec-timezoneestring' + }, + ToBigInt: { + url: 'https://262.ecma-international.org/11.0/#sec-tobigint' + }, + ToBigInt64: { + url: 'https://262.ecma-international.org/11.0/#sec-tobigint64' + }, + ToBigUint64: { + url: 'https://262.ecma-international.org/11.0/#sec-tobiguint64' + }, + ToBoolean: { + url: 'https://262.ecma-international.org/11.0/#sec-toboolean' + }, + ToDateString: { + url: 'https://262.ecma-international.org/11.0/#sec-todatestring' + }, + ToIndex: { + url: 'https://262.ecma-international.org/11.0/#sec-toindex' + }, + ToInt16: { + url: 'https://262.ecma-international.org/11.0/#sec-toint16' + }, + ToInt32: { + url: 'https://262.ecma-international.org/11.0/#sec-toint32' + }, + ToInt8: { + url: 'https://262.ecma-international.org/11.0/#sec-toint8' + }, + ToInteger: { + url: 'https://262.ecma-international.org/11.0/#sec-tointeger' + }, + ToLength: { + url: 'https://262.ecma-international.org/11.0/#sec-tolength' + }, + ToNumber: { + url: 'https://262.ecma-international.org/11.0/#sec-tonumber' + }, + ToNumeric: { + url: 'https://262.ecma-international.org/11.0/#sec-tonumeric' + }, + ToObject: { + url: 'https://262.ecma-international.org/11.0/#sec-toobject' + }, + ToPrimitive: { + url: 'https://262.ecma-international.org/11.0/#sec-toprimitive' + }, + ToPropertyDescriptor: { + url: 'https://262.ecma-international.org/11.0/#sec-topropertydescriptor' + }, + ToPropertyKey: { + url: 'https://262.ecma-international.org/11.0/#sec-topropertykey' + }, + ToString: { + url: 'https://262.ecma-international.org/11.0/#sec-tostring' + }, + ToUint16: { + url: 'https://262.ecma-international.org/11.0/#sec-touint16' + }, + ToUint32: { + url: 'https://262.ecma-international.org/11.0/#sec-touint32' + }, + ToUint8: { + url: 'https://262.ecma-international.org/11.0/#sec-touint8' + }, + ToUint8Clamp: { + url: 'https://262.ecma-international.org/11.0/#sec-touint8clamp' + }, + TriggerPromiseReactions: { + url: 'https://262.ecma-international.org/11.0/#sec-triggerpromisereactions' + }, + TrimString: { + url: 'https://262.ecma-international.org/11.0/#sec-trimstring' + }, + Type: { + url: 'https://262.ecma-international.org/11.0/#sec-ecmascript-data-types-and-values' + }, + TypedArrayCreate: { + url: 'https://262.ecma-international.org/11.0/#typedarray-create' + }, + TypedArraySpeciesCreate: { + url: 'https://262.ecma-international.org/11.0/#typedarray-species-create' + }, + UnicodeEscape: { + url: 'https://262.ecma-international.org/11.0/#sec-unicodeescape' + }, + UnicodeMatchProperty: { + url: 'https://262.ecma-international.org/11.0/#sec-runtime-semantics-unicodematchproperty-p' + }, + UnicodeMatchPropertyValue: { + url: 'https://262.ecma-international.org/11.0/#sec-runtime-semantics-unicodematchpropertyvalue-p-v' + }, + UpdateEmpty: { + url: 'https://262.ecma-international.org/11.0/#sec-updateempty' + }, + UTC: { + url: 'https://262.ecma-international.org/11.0/#sec-utc-t' + }, + UTF16DecodeString: { + url: 'https://262.ecma-international.org/11.0/#sec-utf16decodestring' + }, + UTF16DecodeSurrogatePair: { + url: 'https://262.ecma-international.org/11.0/#sec-utf16decodesurrogatepair' + }, + UTF16Encode: { + url: 'https://262.ecma-international.org/11.0/#sec-utf16encode' + }, + UTF16Encoding: { + url: 'https://262.ecma-international.org/11.0/#sec-utf16encoding' + }, + ValidateAndApplyPropertyDescriptor: { + url: 'https://262.ecma-international.org/11.0/#sec-validateandapplypropertydescriptor' + }, + ValidateAtomicAccess: { + url: 'https://262.ecma-international.org/11.0/#sec-validateatomicaccess' + }, + ValidateSharedIntegerTypedArray: { + url: 'https://262.ecma-international.org/11.0/#sec-validatesharedintegertypedarray' + }, + ValidateTypedArray: { + url: 'https://262.ecma-international.org/11.0/#sec-validatetypedarray' + }, + ValueOfReadEvent: { + url: 'https://262.ecma-international.org/11.0/#sec-valueofreadevent' + }, + WeekDay: { + url: 'https://262.ecma-international.org/11.0/#sec-week-day' + }, + WordCharacters: { + url: 'https://262.ecma-international.org/11.0/#sec-runtime-semantics-wordcharacters-abstract-operation' + }, + YearFromTime: { + url: 'https://262.ecma-international.org/11.0/#eqn-YearFromTime' + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2021.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2021.js new file mode 100644 index 0000000000000000000000000000000000000000..7d4ff210a596d7364a063af5b392f7f28bda94f2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2021.js @@ -0,0 +1,1282 @@ +'use strict'; + +module.exports = { + abs: { + url: 'https://262.ecma-international.org/12.0/#eqn-abs' + }, + 'Abstract Equality Comparison': { + url: 'https://262.ecma-international.org/12.0/#sec-abstract-equality-comparison' + }, + 'Abstract Relational Comparison': { + url: 'https://262.ecma-international.org/12.0/#sec-abstract-relational-comparison' + }, + AddEntriesFromIterable: { + url: 'https://262.ecma-international.org/12.0/#sec-add-entries-from-iterable' + }, + AddRestrictedFunctionProperties: { + url: 'https://262.ecma-international.org/12.0/#sec-addrestrictedfunctionproperties' + }, + AddToKeptObjects: { + url: 'https://262.ecma-international.org/12.0/#sec-addtokeptobjects' + }, + AddWaiter: { + url: 'https://262.ecma-international.org/12.0/#sec-addwaiter' + }, + AdvanceStringIndex: { + url: 'https://262.ecma-international.org/12.0/#sec-advancestringindex' + }, + 'agent-order': { + url: 'https://262.ecma-international.org/12.0/#sec-agent-order' + }, + AgentCanSuspend: { + url: 'https://262.ecma-international.org/12.0/#sec-agentcansuspend' + }, + AgentSignifier: { + url: 'https://262.ecma-international.org/12.0/#sec-agentsignifier' + }, + AllocateArrayBuffer: { + url: 'https://262.ecma-international.org/12.0/#sec-allocatearraybuffer' + }, + AllocateSharedArrayBuffer: { + url: 'https://262.ecma-international.org/12.0/#sec-allocatesharedarraybuffer' + }, + AllocateTypedArray: { + url: 'https://262.ecma-international.org/12.0/#sec-allocatetypedarray' + }, + AllocateTypedArrayBuffer: { + url: 'https://262.ecma-international.org/12.0/#sec-allocatetypedarraybuffer' + }, + ApplyStringOrNumericBinaryOperator: { + url: 'https://262.ecma-international.org/12.0/#sec-applystringornumericbinaryoperator' + }, + ArrayCreate: { + url: 'https://262.ecma-international.org/12.0/#sec-arraycreate' + }, + ArraySetLength: { + url: 'https://262.ecma-international.org/12.0/#sec-arraysetlength' + }, + ArraySpeciesCreate: { + url: 'https://262.ecma-international.org/12.0/#sec-arrayspeciescreate' + }, + AsyncFromSyncIteratorContinuation: { + url: 'https://262.ecma-international.org/12.0/#sec-asyncfromsynciteratorcontinuation' + }, + AsyncFunctionStart: { + url: 'https://262.ecma-international.org/12.0/#sec-async-functions-abstract-operations-async-function-start' + }, + AsyncGeneratorEnqueue: { + url: 'https://262.ecma-international.org/12.0/#sec-asyncgeneratorenqueue' + }, + AsyncGeneratorReject: { + url: 'https://262.ecma-international.org/12.0/#sec-asyncgeneratorreject' + }, + AsyncGeneratorResolve: { + url: 'https://262.ecma-international.org/12.0/#sec-asyncgeneratorresolve' + }, + AsyncGeneratorResumeNext: { + url: 'https://262.ecma-international.org/12.0/#sec-asyncgeneratorresumenext' + }, + AsyncGeneratorStart: { + url: 'https://262.ecma-international.org/12.0/#sec-asyncgeneratorstart' + }, + AsyncGeneratorValidate: { + url: 'https://262.ecma-international.org/12.0/#sec-asyncgeneratorvalidate' + }, + AsyncGeneratorYield: { + url: 'https://262.ecma-international.org/12.0/#sec-asyncgeneratoryield' + }, + AsyncIteratorClose: { + url: 'https://262.ecma-international.org/12.0/#sec-asynciteratorclose' + }, + AtomicReadModifyWrite: { + url: 'https://262.ecma-international.org/12.0/#sec-atomicreadmodifywrite' + }, + Await: { + url: 'https://262.ecma-international.org/12.0/#await' + }, + BackreferenceMatcher: { + url: 'https://262.ecma-international.org/12.0/#sec-backreference-matcher' + }, + 'BigInt::add': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-bigint-add' + }, + 'BigInt::bitwiseAND': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-bigint-bitwiseAND' + }, + 'BigInt::bitwiseNOT': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-bigint-bitwiseNOT' + }, + 'BigInt::bitwiseOR': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-bigint-bitwiseOR' + }, + 'BigInt::bitwiseXOR': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-bigint-bitwiseXOR' + }, + 'BigInt::divide': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-bigint-divide' + }, + 'BigInt::equal': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-bigint-equal' + }, + 'BigInt::exponentiate': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-bigint-exponentiate' + }, + 'BigInt::leftShift': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-bigint-leftShift' + }, + 'BigInt::lessThan': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-bigint-lessThan' + }, + 'BigInt::multiply': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-bigint-multiply' + }, + 'BigInt::remainder': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-bigint-remainder' + }, + 'BigInt::sameValue': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-bigint-sameValue' + }, + 'BigInt::sameValueZero': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-bigint-sameValueZero' + }, + 'BigInt::signedRightShift': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-bigint-signedRightShift' + }, + 'BigInt::subtract': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-bigint-subtract' + }, + 'BigInt::toString': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-bigint-tostring' + }, + 'BigInt::unaryMinus': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-bigint-unaryMinus' + }, + 'BigInt::unsignedRightShift': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-bigint-unsignedRightShift' + }, + BigIntBitwiseOp: { + url: 'https://262.ecma-international.org/12.0/#sec-bigintbitwiseop' + }, + BinaryAnd: { + url: 'https://262.ecma-international.org/12.0/#sec-binaryand' + }, + BinaryOr: { + url: 'https://262.ecma-international.org/12.0/#sec-binaryor' + }, + BinaryXor: { + url: 'https://262.ecma-international.org/12.0/#sec-binaryxor' + }, + BlockDeclarationInstantiation: { + url: 'https://262.ecma-international.org/12.0/#sec-blockdeclarationinstantiation' + }, + BoundFunctionCreate: { + url: 'https://262.ecma-international.org/12.0/#sec-boundfunctioncreate' + }, + ByteListBitwiseOp: { + url: 'https://262.ecma-international.org/12.0/#sec-bytelistbitwiseop' + }, + ByteListEqual: { + url: 'https://262.ecma-international.org/12.0/#sec-bytelistequal' + }, + Call: { + url: 'https://262.ecma-international.org/12.0/#sec-call' + }, + Canonicalize: { + url: 'https://262.ecma-international.org/12.0/#sec-runtime-semantics-canonicalize-ch' + }, + CanonicalNumericIndexString: { + url: 'https://262.ecma-international.org/12.0/#sec-canonicalnumericindexstring' + }, + CaseClauseIsSelected: { + url: 'https://262.ecma-international.org/12.0/#sec-runtime-semantics-caseclauseisselected' + }, + CharacterRange: { + url: 'https://262.ecma-international.org/12.0/#sec-runtime-semantics-characterrange-abstract-operation' + }, + CharacterRangeOrUnion: { + url: 'https://262.ecma-international.org/12.0/#sec-runtime-semantics-characterrangeorunion-abstract-operation' + }, + CharacterSetMatcher: { + url: 'https://262.ecma-international.org/12.0/#sec-runtime-semantics-charactersetmatcher-abstract-operation' + }, + clamp: { + url: 'https://262.ecma-international.org/12.0/#clamping' + }, + CleanupFinalizationRegistry: { + url: 'https://262.ecma-international.org/12.0/#sec-cleanup-finalization-registry' + }, + ClearKeptObjects: { + url: 'https://262.ecma-international.org/12.0/#sec-clear-kept-objects' + }, + CloneArrayBuffer: { + url: 'https://262.ecma-international.org/12.0/#sec-clonearraybuffer' + }, + CodePointAt: { + url: 'https://262.ecma-international.org/12.0/#sec-codepointat' + }, + CodePointsToString: { + url: 'https://262.ecma-international.org/12.0/#sec-codepointstostring' + }, + CompletePropertyDescriptor: { + url: 'https://262.ecma-international.org/12.0/#sec-completepropertydescriptor' + }, + Completion: { + url: 'https://262.ecma-international.org/12.0/#sec-completion-record-specification-type' + }, + CompletionRecord: { + url: 'https://262.ecma-international.org/12.0/#sec-completion-record-specification-type' + }, + ComposeWriteEventBytes: { + url: 'https://262.ecma-international.org/12.0/#sec-composewriteeventbytes' + }, + Construct: { + url: 'https://262.ecma-international.org/12.0/#sec-construct' + }, + CopyDataBlockBytes: { + url: 'https://262.ecma-international.org/12.0/#sec-copydatablockbytes' + }, + CopyDataProperties: { + url: 'https://262.ecma-international.org/12.0/#sec-copydataproperties' + }, + CreateArrayFromList: { + url: 'https://262.ecma-international.org/12.0/#sec-createarrayfromlist' + }, + CreateArrayIterator: { + url: 'https://262.ecma-international.org/12.0/#sec-createarrayiterator' + }, + CreateAsyncFromSyncIterator: { + url: 'https://262.ecma-international.org/12.0/#sec-createasyncfromsynciterator' + }, + CreateAsyncIteratorFromClosure: { + url: 'https://262.ecma-international.org/12.0/#sec-createasynciteratorfromclosure' + }, + CreateBuiltinFunction: { + url: 'https://262.ecma-international.org/12.0/#sec-createbuiltinfunction' + }, + CreateByteDataBlock: { + url: 'https://262.ecma-international.org/12.0/#sec-createbytedatablock' + }, + CreateDataProperty: { + url: 'https://262.ecma-international.org/12.0/#sec-createdataproperty' + }, + CreateDataPropertyOrThrow: { + url: 'https://262.ecma-international.org/12.0/#sec-createdatapropertyorthrow' + }, + CreateDynamicFunction: { + url: 'https://262.ecma-international.org/12.0/#sec-createdynamicfunction' + }, + CreateForInIterator: { + url: 'https://262.ecma-international.org/12.0/#sec-createforiniterator' + }, + CreateHTML: { + url: 'https://262.ecma-international.org/12.0/#sec-createhtml' + }, + CreateIntrinsics: { + url: 'https://262.ecma-international.org/12.0/#sec-createintrinsics' + }, + CreateIteratorFromClosure: { + url: 'https://262.ecma-international.org/12.0/#sec-createiteratorfromclosure' + }, + CreateIterResultObject: { + url: 'https://262.ecma-international.org/12.0/#sec-createiterresultobject' + }, + CreateListFromArrayLike: { + url: 'https://262.ecma-international.org/12.0/#sec-createlistfromarraylike' + }, + CreateListIteratorRecord: { + url: 'https://262.ecma-international.org/12.0/#sec-createlistiteratorRecord' + }, + CreateMapIterator: { + url: 'https://262.ecma-international.org/12.0/#sec-createmapiterator' + }, + CreateMappedArgumentsObject: { + url: 'https://262.ecma-international.org/12.0/#sec-createmappedargumentsobject' + }, + CreateMethodProperty: { + url: 'https://262.ecma-international.org/12.0/#sec-createmethodproperty' + }, + CreatePerIterationEnvironment: { + url: 'https://262.ecma-international.org/12.0/#sec-createperiterationenvironment' + }, + CreateRealm: { + url: 'https://262.ecma-international.org/12.0/#sec-createrealm' + }, + CreateRegExpStringIterator: { + url: 'https://262.ecma-international.org/12.0/#sec-createregexpstringiterator' + }, + CreateResolvingFunctions: { + url: 'https://262.ecma-international.org/12.0/#sec-createresolvingfunctions' + }, + CreateSetIterator: { + url: 'https://262.ecma-international.org/12.0/#sec-createsetiterator' + }, + CreateSharedByteDataBlock: { + url: 'https://262.ecma-international.org/12.0/#sec-createsharedbytedatablock' + }, + CreateUnmappedArgumentsObject: { + url: 'https://262.ecma-international.org/12.0/#sec-createunmappedargumentsobject' + }, + DateFromTime: { + url: 'https://262.ecma-international.org/12.0/#sec-date-number' + }, + DateString: { + url: 'https://262.ecma-international.org/12.0/#sec-datestring' + }, + Day: { + url: 'https://262.ecma-international.org/12.0/#eqn-Day' + }, + DayFromYear: { + url: 'https://262.ecma-international.org/12.0/#eqn-DaysFromYear' + }, + DaysInYear: { + url: 'https://262.ecma-international.org/12.0/#eqn-DaysInYear' + }, + DayWithinYear: { + url: 'https://262.ecma-international.org/12.0/#eqn-DayWithinYear' + }, + Decode: { + url: 'https://262.ecma-international.org/12.0/#sec-decode' + }, + DefinePropertyOrThrow: { + url: 'https://262.ecma-international.org/12.0/#sec-definepropertyorthrow' + }, + DeletePropertyOrThrow: { + url: 'https://262.ecma-international.org/12.0/#sec-deletepropertyorthrow' + }, + DetachArrayBuffer: { + url: 'https://262.ecma-international.org/12.0/#sec-detacharraybuffer' + }, + Encode: { + url: 'https://262.ecma-international.org/12.0/#sec-encode' + }, + EnterCriticalSection: { + url: 'https://262.ecma-international.org/12.0/#sec-entercriticalsection' + }, + EnumerableOwnPropertyNames: { + url: 'https://262.ecma-international.org/12.0/#sec-enumerableownpropertynames' + }, + EnumerateObjectProperties: { + url: 'https://262.ecma-international.org/12.0/#sec-enumerate-object-properties' + }, + EscapeRegExpPattern: { + url: 'https://262.ecma-international.org/12.0/#sec-escaperegexppattern' + }, + EvalDeclarationInstantiation: { + url: 'https://262.ecma-international.org/12.0/#sec-evaldeclarationinstantiation' + }, + EvaluateCall: { + url: 'https://262.ecma-international.org/12.0/#sec-evaluatecall' + }, + EvaluateNew: { + url: 'https://262.ecma-international.org/12.0/#sec-evaluatenew' + }, + EvaluatePropertyAccessWithExpressionKey: { + url: 'https://262.ecma-international.org/12.0/#sec-evaluate-property-access-with-expression-key' + }, + EvaluatePropertyAccessWithIdentifierKey: { + url: 'https://262.ecma-international.org/12.0/#sec-evaluate-property-access-with-identifier-key' + }, + EvaluateStringOrNumericBinaryExpression: { + url: 'https://262.ecma-international.org/12.0/#sec-evaluatestringornumericbinaryexpression' + }, + EventSet: { + url: 'https://262.ecma-international.org/12.0/#sec-event-set' + }, + ExecuteModule: { + url: 'https://262.ecma-international.org/12.0/#sec-source-text-module-record-execute-module' + }, + FinishDynamicImport: { + url: 'https://262.ecma-international.org/12.0/#sec-finishdynamicimport' + }, + FlattenIntoArray: { + url: 'https://262.ecma-international.org/12.0/#sec-flattenintoarray' + }, + floor: { + url: 'https://262.ecma-international.org/12.0/#eqn-floor' + }, + ForBodyEvaluation: { + url: 'https://262.ecma-international.org/12.0/#sec-forbodyevaluation' + }, + 'ForIn/OfBodyEvaluation': { + url: 'https://262.ecma-international.org/12.0/#sec-runtime-semantics-forin-div-ofbodyevaluation-lhs-stmt-iterator-lhskind-labelset' + }, + 'ForIn/OfHeadEvaluation': { + url: 'https://262.ecma-international.org/12.0/#sec-runtime-semantics-forinofheadevaluation' + }, + FromPropertyDescriptor: { + url: 'https://262.ecma-international.org/12.0/#sec-frompropertydescriptor' + }, + FulfillPromise: { + url: 'https://262.ecma-international.org/12.0/#sec-fulfillpromise' + }, + FunctionDeclarationInstantiation: { + url: 'https://262.ecma-international.org/12.0/#sec-functiondeclarationinstantiation' + }, + GeneratorResume: { + url: 'https://262.ecma-international.org/12.0/#sec-generatorresume' + }, + GeneratorResumeAbrupt: { + url: 'https://262.ecma-international.org/12.0/#sec-generatorresumeabrupt' + }, + GeneratorStart: { + url: 'https://262.ecma-international.org/12.0/#sec-generatorstart' + }, + GeneratorValidate: { + url: 'https://262.ecma-international.org/12.0/#sec-generatorvalidate' + }, + GeneratorYield: { + url: 'https://262.ecma-international.org/12.0/#sec-generatoryield' + }, + Get: { + url: 'https://262.ecma-international.org/12.0/#sec-get-o-p' + }, + GetActiveScriptOrModule: { + url: 'https://262.ecma-international.org/12.0/#sec-getactivescriptormodule' + }, + GetFunctionRealm: { + url: 'https://262.ecma-international.org/12.0/#sec-getfunctionrealm' + }, + GetGeneratorKind: { + url: 'https://262.ecma-international.org/12.0/#sec-getgeneratorkind' + }, + GetGlobalObject: { + url: 'https://262.ecma-international.org/12.0/#sec-getglobalobject' + }, + GetIdentifierReference: { + url: 'https://262.ecma-international.org/12.0/#sec-getidentifierreference' + }, + GetIterator: { + url: 'https://262.ecma-international.org/12.0/#sec-getiterator' + }, + GetMethod: { + url: 'https://262.ecma-international.org/12.0/#sec-getmethod' + }, + GetModifySetValueInBuffer: { + url: 'https://262.ecma-international.org/12.0/#sec-getmodifysetvalueinbuffer' + }, + GetModuleNamespace: { + url: 'https://262.ecma-international.org/12.0/#sec-getmodulenamespace' + }, + GetNewTarget: { + url: 'https://262.ecma-international.org/12.0/#sec-getnewtarget' + }, + GetOwnPropertyKeys: { + url: 'https://262.ecma-international.org/12.0/#sec-getownpropertykeys' + }, + GetPromiseResolve: { + url: 'https://262.ecma-international.org/12.0/#sec-getpromiseresolve' + }, + GetPrototypeFromConstructor: { + url: 'https://262.ecma-international.org/12.0/#sec-getprototypefromconstructor' + }, + GetSubstitution: { + url: 'https://262.ecma-international.org/12.0/#sec-getsubstitution' + }, + GetSuperConstructor: { + url: 'https://262.ecma-international.org/12.0/#sec-getsuperconstructor' + }, + GetTemplateObject: { + url: 'https://262.ecma-international.org/12.0/#sec-gettemplateobject' + }, + GetThisEnvironment: { + url: 'https://262.ecma-international.org/12.0/#sec-getthisenvironment' + }, + GetThisValue: { + url: 'https://262.ecma-international.org/12.0/#sec-getthisvalue' + }, + GetV: { + url: 'https://262.ecma-international.org/12.0/#sec-getv' + }, + GetValue: { + url: 'https://262.ecma-international.org/12.0/#sec-getvalue' + }, + GetValueFromBuffer: { + url: 'https://262.ecma-international.org/12.0/#sec-getvaluefrombuffer' + }, + GetViewValue: { + url: 'https://262.ecma-international.org/12.0/#sec-getviewvalue' + }, + GetWaiterList: { + url: 'https://262.ecma-international.org/12.0/#sec-getwaiterlist' + }, + GlobalDeclarationInstantiation: { + url: 'https://262.ecma-international.org/12.0/#sec-globaldeclarationinstantiation' + }, + 'happens-before': { + url: 'https://262.ecma-international.org/12.0/#sec-happens-before' + }, + HasOwnProperty: { + url: 'https://262.ecma-international.org/12.0/#sec-hasownproperty' + }, + HasProperty: { + url: 'https://262.ecma-international.org/12.0/#sec-hasproperty' + }, + 'host-synchronizes-with': { + url: 'https://262.ecma-international.org/12.0/#sec-host-synchronizes-with' + }, + HostEventSet: { + url: 'https://262.ecma-international.org/12.0/#sec-hosteventset' + }, + HourFromTime: { + url: 'https://262.ecma-international.org/12.0/#eqn-HourFromTime' + }, + IfAbruptRejectPromise: { + url: 'https://262.ecma-international.org/12.0/#sec-ifabruptrejectpromise' + }, + ImportedLocalNames: { + url: 'https://262.ecma-international.org/12.0/#sec-importedlocalnames' + }, + InitializeBoundName: { + url: 'https://262.ecma-international.org/12.0/#sec-initializeboundname' + }, + InitializeEnvironment: { + url: 'https://262.ecma-international.org/12.0/#sec-source-text-module-record-initialize-environment' + }, + InitializeHostDefinedRealm: { + url: 'https://262.ecma-international.org/12.0/#sec-initializehostdefinedrealm' + }, + InitializeReferencedBinding: { + url: 'https://262.ecma-international.org/12.0/#sec-initializereferencedbinding' + }, + InitializeTypedArrayFromArrayBuffer: { + url: 'https://262.ecma-international.org/12.0/#sec-initializetypedarrayfromarraybuffer' + }, + InitializeTypedArrayFromArrayLike: { + url: 'https://262.ecma-international.org/12.0/#sec-initializetypedarrayfromarraylike' + }, + InitializeTypedArrayFromList: { + url: 'https://262.ecma-international.org/12.0/#sec-initializetypedarrayfromlist' + }, + InitializeTypedArrayFromTypedArray: { + url: 'https://262.ecma-international.org/12.0/#sec-initializetypedarrayfromtypedarray' + }, + InLeapYear: { + url: 'https://262.ecma-international.org/12.0/#eqn-InLeapYear' + }, + InnerModuleEvaluation: { + url: 'https://262.ecma-international.org/12.0/#sec-innermoduleevaluation' + }, + InnerModuleLinking: { + url: 'https://262.ecma-international.org/12.0/#sec-InnerModuleLinking' + }, + InstanceofOperator: { + url: 'https://262.ecma-international.org/12.0/#sec-instanceofoperator' + }, + IntegerIndexedElementGet: { + url: 'https://262.ecma-international.org/12.0/#sec-integerindexedelementget' + }, + IntegerIndexedElementSet: { + url: 'https://262.ecma-international.org/12.0/#sec-integerindexedelementset' + }, + IntegerIndexedObjectCreate: { + url: 'https://262.ecma-international.org/12.0/#sec-integerindexedobjectcreate' + }, + InternalizeJSONProperty: { + url: 'https://262.ecma-international.org/12.0/#sec-internalizejsonproperty' + }, + Invoke: { + url: 'https://262.ecma-international.org/12.0/#sec-invoke' + }, + IsAccessorDescriptor: { + url: 'https://262.ecma-international.org/12.0/#sec-isaccessordescriptor' + }, + IsAnonymousFunctionDefinition: { + url: 'https://262.ecma-international.org/12.0/#sec-isanonymousfunctiondefinition' + }, + IsArray: { + url: 'https://262.ecma-international.org/12.0/#sec-isarray' + }, + IsBigIntElementType: { + url: 'https://262.ecma-international.org/12.0/#sec-isbigintelementtype' + }, + IsCallable: { + url: 'https://262.ecma-international.org/12.0/#sec-iscallable' + }, + IsCompatiblePropertyDescriptor: { + url: 'https://262.ecma-international.org/12.0/#sec-iscompatiblepropertydescriptor' + }, + IsConcatSpreadable: { + url: 'https://262.ecma-international.org/12.0/#sec-isconcatspreadable' + }, + IsConstructor: { + url: 'https://262.ecma-international.org/12.0/#sec-isconstructor' + }, + IsDataDescriptor: { + url: 'https://262.ecma-international.org/12.0/#sec-isdatadescriptor' + }, + IsDetachedBuffer: { + url: 'https://262.ecma-international.org/12.0/#sec-isdetachedbuffer' + }, + IsExtensible: { + url: 'https://262.ecma-international.org/12.0/#sec-isextensible-o' + }, + IsGenericDescriptor: { + url: 'https://262.ecma-international.org/12.0/#sec-isgenericdescriptor' + }, + IsInTailPosition: { + url: 'https://262.ecma-international.org/12.0/#sec-isintailposition' + }, + IsIntegralNumber: { + url: 'https://262.ecma-international.org/12.0/#sec-isintegralnumber' + }, + IsLabelledFunction: { + url: 'https://262.ecma-international.org/12.0/#sec-islabelledfunction' + }, + IsNoTearConfiguration: { + url: 'https://262.ecma-international.org/12.0/#sec-isnotearconfiguration' + }, + IsPromise: { + url: 'https://262.ecma-international.org/12.0/#sec-ispromise' + }, + IsPropertyKey: { + url: 'https://262.ecma-international.org/12.0/#sec-ispropertykey' + }, + IsPropertyReference: { + url: 'https://262.ecma-international.org/12.0/#sec-ispropertyreference' + }, + IsRegExp: { + url: 'https://262.ecma-international.org/12.0/#sec-isregexp' + }, + IsSharedArrayBuffer: { + url: 'https://262.ecma-international.org/12.0/#sec-issharedarraybuffer' + }, + IsStringPrefix: { + url: 'https://262.ecma-international.org/12.0/#sec-isstringprefix' + }, + IsSuperReference: { + url: 'https://262.ecma-international.org/12.0/#sec-issuperreference' + }, + IsUnclampedIntegerElementType: { + url: 'https://262.ecma-international.org/12.0/#sec-isunclampedintegerelementtype' + }, + IsUnresolvableReference: { + url: 'https://262.ecma-international.org/12.0/#sec-isunresolvablereference' + }, + IsUnsignedElementType: { + url: 'https://262.ecma-international.org/12.0/#sec-isunsignedelementtype' + }, + IsValidIntegerIndex: { + url: 'https://262.ecma-international.org/12.0/#sec-isvalidintegerindex' + }, + IsValidRegularExpressionLiteral: { + url: 'https://262.ecma-international.org/12.0/#sec-isvalidregularexpressionliteral' + }, + IsWordChar: { + url: 'https://262.ecma-international.org/12.0/#sec-runtime-semantics-iswordchar-abstract-operation' + }, + IterableToList: { + url: 'https://262.ecma-international.org/12.0/#sec-iterabletolist' + }, + IteratorClose: { + url: 'https://262.ecma-international.org/12.0/#sec-iteratorclose' + }, + IteratorComplete: { + url: 'https://262.ecma-international.org/12.0/#sec-iteratorcomplete' + }, + IteratorNext: { + url: 'https://262.ecma-international.org/12.0/#sec-iteratornext' + }, + IteratorStep: { + url: 'https://262.ecma-international.org/12.0/#sec-iteratorstep' + }, + IteratorValue: { + url: 'https://262.ecma-international.org/12.0/#sec-iteratorvalue' + }, + LeaveCriticalSection: { + url: 'https://262.ecma-international.org/12.0/#sec-leavecriticalsection' + }, + LengthOfArrayLike: { + url: 'https://262.ecma-international.org/12.0/#sec-lengthofarraylike' + }, + LocalTime: { + url: 'https://262.ecma-international.org/12.0/#sec-localtime' + }, + LocalTZA: { + url: 'https://262.ecma-international.org/12.0/#sec-local-time-zone-adjustment' + }, + LoopContinues: { + url: 'https://262.ecma-international.org/12.0/#sec-loopcontinues' + }, + MakeArgGetter: { + url: 'https://262.ecma-international.org/12.0/#sec-makearggetter' + }, + MakeArgSetter: { + url: 'https://262.ecma-international.org/12.0/#sec-makeargsetter' + }, + MakeBasicObject: { + url: 'https://262.ecma-international.org/12.0/#sec-makebasicobject' + }, + MakeClassConstructor: { + url: 'https://262.ecma-international.org/12.0/#sec-makeclassconstructor' + }, + MakeConstructor: { + url: 'https://262.ecma-international.org/12.0/#sec-makeconstructor' + }, + MakeDate: { + url: 'https://262.ecma-international.org/12.0/#sec-makedate' + }, + MakeDay: { + url: 'https://262.ecma-international.org/12.0/#sec-makeday' + }, + MakeMethod: { + url: 'https://262.ecma-international.org/12.0/#sec-makemethod' + }, + MakeSuperPropertyReference: { + url: 'https://262.ecma-international.org/12.0/#sec-makesuperpropertyreference' + }, + MakeTime: { + url: 'https://262.ecma-international.org/12.0/#sec-maketime' + }, + max: { + url: 'https://262.ecma-international.org/12.0/#eqn-max' + }, + 'memory-order': { + url: 'https://262.ecma-international.org/12.0/#sec-memory-order' + }, + min: { + url: 'https://262.ecma-international.org/12.0/#eqn-min' + }, + MinFromTime: { + url: 'https://262.ecma-international.org/12.0/#eqn-MinFromTime' + }, + ModuleNamespaceCreate: { + url: 'https://262.ecma-international.org/12.0/#sec-modulenamespacecreate' + }, + modulo: { + url: 'https://262.ecma-international.org/12.0/#eqn-modulo' + }, + MonthFromTime: { + url: 'https://262.ecma-international.org/12.0/#eqn-MonthFromTime' + }, + msFromTime: { + url: 'https://262.ecma-international.org/12.0/#eqn-msFromTime' + }, + NewDeclarativeEnvironment: { + url: 'https://262.ecma-international.org/12.0/#sec-newdeclarativeenvironment' + }, + NewFunctionEnvironment: { + url: 'https://262.ecma-international.org/12.0/#sec-newfunctionenvironment' + }, + NewGlobalEnvironment: { + url: 'https://262.ecma-international.org/12.0/#sec-newglobalenvironment' + }, + NewModuleEnvironment: { + url: 'https://262.ecma-international.org/12.0/#sec-newmoduleenvironment' + }, + NewObjectEnvironment: { + url: 'https://262.ecma-international.org/12.0/#sec-newobjectenvironment' + }, + NewPromiseCapability: { + url: 'https://262.ecma-international.org/12.0/#sec-newpromisecapability' + }, + NewPromiseReactionJob: { + url: 'https://262.ecma-international.org/12.0/#sec-newpromisereactionjob' + }, + NewPromiseResolveThenableJob: { + url: 'https://262.ecma-international.org/12.0/#sec-newpromiseresolvethenablejob' + }, + NormalCompletion: { + url: 'https://262.ecma-international.org/12.0/#sec-normalcompletion' + }, + NotifyWaiter: { + url: 'https://262.ecma-international.org/12.0/#sec-notifywaiter' + }, + 'Number::add': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-number-add' + }, + 'Number::bitwiseAND': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-number-bitwiseAND' + }, + 'Number::bitwiseNOT': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-number-bitwiseNOT' + }, + 'Number::bitwiseOR': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-number-bitwiseOR' + }, + 'Number::bitwiseXOR': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-number-bitwiseXOR' + }, + 'Number::divide': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-number-divide' + }, + 'Number::equal': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-number-equal' + }, + 'Number::exponentiate': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-number-exponentiate' + }, + 'Number::leftShift': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-number-leftShift' + }, + 'Number::lessThan': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-number-lessThan' + }, + 'Number::multiply': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-number-multiply' + }, + 'Number::remainder': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-number-remainder' + }, + 'Number::sameValue': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-number-sameValue' + }, + 'Number::sameValueZero': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-number-sameValueZero' + }, + 'Number::signedRightShift': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-number-signedRightShift' + }, + 'Number::subtract': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-number-subtract' + }, + 'Number::toString': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-number-tostring' + }, + 'Number::unaryMinus': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-number-unaryMinus' + }, + 'Number::unsignedRightShift': { + url: 'https://262.ecma-international.org/12.0/#sec-numeric-types-number-unsignedRightShift' + }, + NumberBitwiseOp: { + url: 'https://262.ecma-international.org/12.0/#sec-numberbitwiseop' + }, + NumberToBigInt: { + url: 'https://262.ecma-international.org/12.0/#sec-numbertobigint' + }, + NumericToRawBytes: { + url: 'https://262.ecma-international.org/12.0/#sec-numerictorawbytes' + }, + ObjectDefineProperties: { + url: 'https://262.ecma-international.org/12.0/#sec-objectdefineproperties' + }, + OrdinaryCallBindThis: { + url: 'https://262.ecma-international.org/12.0/#sec-ordinarycallbindthis' + }, + OrdinaryCallEvaluateBody: { + url: 'https://262.ecma-international.org/12.0/#sec-ordinarycallevaluatebody' + }, + OrdinaryCreateFromConstructor: { + url: 'https://262.ecma-international.org/12.0/#sec-ordinarycreatefromconstructor' + }, + OrdinaryDefineOwnProperty: { + url: 'https://262.ecma-international.org/12.0/#sec-ordinarydefineownproperty' + }, + OrdinaryDelete: { + url: 'https://262.ecma-international.org/12.0/#sec-ordinarydelete' + }, + OrdinaryFunctionCreate: { + url: 'https://262.ecma-international.org/12.0/#sec-ordinaryfunctioncreate' + }, + OrdinaryGet: { + url: 'https://262.ecma-international.org/12.0/#sec-ordinaryget' + }, + OrdinaryGetOwnProperty: { + url: 'https://262.ecma-international.org/12.0/#sec-ordinarygetownproperty' + }, + OrdinaryGetPrototypeOf: { + url: 'https://262.ecma-international.org/12.0/#sec-ordinarygetprototypeof' + }, + OrdinaryHasInstance: { + url: 'https://262.ecma-international.org/12.0/#sec-ordinaryhasinstance' + }, + OrdinaryHasProperty: { + url: 'https://262.ecma-international.org/12.0/#sec-ordinaryhasproperty' + }, + OrdinaryIsExtensible: { + url: 'https://262.ecma-international.org/12.0/#sec-ordinaryisextensible' + }, + OrdinaryObjectCreate: { + url: 'https://262.ecma-international.org/12.0/#sec-ordinaryobjectcreate' + }, + OrdinaryOwnPropertyKeys: { + url: 'https://262.ecma-international.org/12.0/#sec-ordinaryownpropertykeys' + }, + OrdinaryPreventExtensions: { + url: 'https://262.ecma-international.org/12.0/#sec-ordinarypreventextensions' + }, + OrdinarySet: { + url: 'https://262.ecma-international.org/12.0/#sec-ordinaryset' + }, + OrdinarySetPrototypeOf: { + url: 'https://262.ecma-international.org/12.0/#sec-ordinarysetprototypeof' + }, + OrdinarySetWithOwnDescriptor: { + url: 'https://262.ecma-international.org/12.0/#sec-ordinarysetwithowndescriptor' + }, + OrdinaryToPrimitive: { + url: 'https://262.ecma-international.org/12.0/#sec-ordinarytoprimitive' + }, + ParseModule: { + url: 'https://262.ecma-international.org/12.0/#sec-parsemodule' + }, + ParsePattern: { + url: 'https://262.ecma-international.org/12.0/#sec-parsepattern' + }, + ParseScript: { + url: 'https://262.ecma-international.org/12.0/#sec-parse-script' + }, + ParseText: { + url: 'https://262.ecma-international.org/12.0/#sec-parsetext' + }, + PerformEval: { + url: 'https://262.ecma-international.org/12.0/#sec-performeval' + }, + PerformPromiseAll: { + url: 'https://262.ecma-international.org/12.0/#sec-performpromiseall' + }, + PerformPromiseAllSettled: { + url: 'https://262.ecma-international.org/12.0/#sec-performpromiseallsettled' + }, + PerformPromiseAny: { + url: 'https://262.ecma-international.org/12.0/#sec-performpromiseany' + }, + PerformPromiseRace: { + url: 'https://262.ecma-international.org/12.0/#sec-performpromiserace' + }, + PerformPromiseThen: { + url: 'https://262.ecma-international.org/12.0/#sec-performpromisethen' + }, + PrepareForOrdinaryCall: { + url: 'https://262.ecma-international.org/12.0/#sec-prepareforordinarycall' + }, + PrepareForTailCall: { + url: 'https://262.ecma-international.org/12.0/#sec-preparefortailcall' + }, + PromiseResolve: { + url: 'https://262.ecma-international.org/12.0/#sec-promise-resolve' + }, + ProxyCreate: { + url: 'https://262.ecma-international.org/12.0/#sec-proxycreate' + }, + PutValue: { + url: 'https://262.ecma-international.org/12.0/#sec-putvalue' + }, + QuoteJSONString: { + url: 'https://262.ecma-international.org/12.0/#sec-quotejsonstring' + }, + RawBytesToNumeric: { + url: 'https://262.ecma-international.org/12.0/#sec-rawbytestonumeric' + }, + 'reads-bytes-from': { + url: 'https://262.ecma-international.org/12.0/#sec-reads-bytes-from' + }, + 'reads-from': { + url: 'https://262.ecma-international.org/12.0/#sec-reads-from' + }, + RegExpAlloc: { + url: 'https://262.ecma-international.org/12.0/#sec-regexpalloc' + }, + RegExpBuiltinExec: { + url: 'https://262.ecma-international.org/12.0/#sec-regexpbuiltinexec' + }, + RegExpCreate: { + url: 'https://262.ecma-international.org/12.0/#sec-regexpcreate' + }, + RegExpExec: { + url: 'https://262.ecma-international.org/12.0/#sec-regexpexec' + }, + RegExpInitialize: { + url: 'https://262.ecma-international.org/12.0/#sec-regexpinitialize' + }, + RejectPromise: { + url: 'https://262.ecma-international.org/12.0/#sec-rejectpromise' + }, + RemoveWaiter: { + url: 'https://262.ecma-international.org/12.0/#sec-removewaiter' + }, + RemoveWaiters: { + url: 'https://262.ecma-international.org/12.0/#sec-removewaiters' + }, + RepeatMatcher: { + url: 'https://262.ecma-international.org/12.0/#sec-runtime-semantics-repeatmatcher-abstract-operation' + }, + RequireInternalSlot: { + url: 'https://262.ecma-international.org/12.0/#sec-requireinternalslot' + }, + RequireObjectCoercible: { + url: 'https://262.ecma-international.org/12.0/#sec-requireobjectcoercible' + }, + ResolveBinding: { + url: 'https://262.ecma-international.org/12.0/#sec-resolvebinding' + }, + ResolveThisBinding: { + url: 'https://262.ecma-international.org/12.0/#sec-resolvethisbinding' + }, + ReturnIfAbrupt: { + url: 'https://262.ecma-international.org/12.0/#sec-returnifabrupt' + }, + SameValue: { + url: 'https://262.ecma-international.org/12.0/#sec-samevalue' + }, + SameValueNonNumeric: { + url: 'https://262.ecma-international.org/12.0/#sec-samevaluenonnumeric' + }, + SameValueZero: { + url: 'https://262.ecma-international.org/12.0/#sec-samevaluezero' + }, + ScriptEvaluation: { + url: 'https://262.ecma-international.org/12.0/#sec-runtime-semantics-scriptevaluation' + }, + SecFromTime: { + url: 'https://262.ecma-international.org/12.0/#eqn-SecFromTime' + }, + SerializeJSONArray: { + url: 'https://262.ecma-international.org/12.0/#sec-serializejsonarray' + }, + SerializeJSONObject: { + url: 'https://262.ecma-international.org/12.0/#sec-serializejsonobject' + }, + SerializeJSONProperty: { + url: 'https://262.ecma-international.org/12.0/#sec-serializejsonproperty' + }, + Set: { + url: 'https://262.ecma-international.org/12.0/#sec-set-o-p-v-throw' + }, + SetDefaultGlobalBindings: { + url: 'https://262.ecma-international.org/12.0/#sec-setdefaultglobalbindings' + }, + SetFunctionLength: { + url: 'https://262.ecma-international.org/12.0/#sec-setfunctionlength' + }, + SetFunctionName: { + url: 'https://262.ecma-international.org/12.0/#sec-setfunctionname' + }, + SetImmutablePrototype: { + url: 'https://262.ecma-international.org/12.0/#sec-set-immutable-prototype' + }, + SetIntegrityLevel: { + url: 'https://262.ecma-international.org/12.0/#sec-setintegritylevel' + }, + SetRealmGlobalObject: { + url: 'https://262.ecma-international.org/12.0/#sec-setrealmglobalobject' + }, + SetTypedArrayFromArrayLike: { + url: 'https://262.ecma-international.org/12.0/#sec-settypedarrayfromarraylike' + }, + SetTypedArrayFromTypedArray: { + url: 'https://262.ecma-international.org/12.0/#sec-settypedarrayfromtypedarray' + }, + SetValueInBuffer: { + url: 'https://262.ecma-international.org/12.0/#sec-setvalueinbuffer' + }, + SetViewValue: { + url: 'https://262.ecma-international.org/12.0/#sec-setviewvalue' + }, + SharedDataBlockEventSet: { + url: 'https://262.ecma-international.org/12.0/#sec-sharedatablockeventset' + }, + SortCompare: { + url: 'https://262.ecma-international.org/12.0/#sec-sortcompare' + }, + SpeciesConstructor: { + url: 'https://262.ecma-international.org/12.0/#sec-speciesconstructor' + }, + SplitMatch: { + url: 'https://262.ecma-international.org/12.0/#sec-splitmatch' + }, + 'Strict Equality Comparison': { + url: 'https://262.ecma-international.org/12.0/#sec-strict-equality-comparison' + }, + StringCreate: { + url: 'https://262.ecma-international.org/12.0/#sec-stringcreate' + }, + StringGetOwnProperty: { + url: 'https://262.ecma-international.org/12.0/#sec-stringgetownproperty' + }, + StringIndexOf: { + url: 'https://262.ecma-international.org/12.0/#sec-stringindexof' + }, + StringPad: { + url: 'https://262.ecma-international.org/12.0/#sec-stringpad' + }, + StringToBigInt: { + url: 'https://262.ecma-international.org/12.0/#sec-stringtobigint' + }, + StringToCodePoints: { + url: 'https://262.ecma-international.org/12.0/#sec-stringtocodepoints' + }, + substring: { + url: 'https://262.ecma-international.org/12.0/#substring' + }, + SuspendAgent: { + url: 'https://262.ecma-international.org/12.0/#sec-suspendagent' + }, + SymbolDescriptiveString: { + url: 'https://262.ecma-international.org/12.0/#sec-symboldescriptivestring' + }, + 'synchronizes-with': { + url: 'https://262.ecma-international.org/12.0/#sec-synchronizes-with' + }, + TestIntegrityLevel: { + url: 'https://262.ecma-international.org/12.0/#sec-testintegritylevel' + }, + thisBigIntValue: { + url: 'https://262.ecma-international.org/12.0/#thisbigintvalue' + }, + thisBooleanValue: { + url: 'https://262.ecma-international.org/12.0/#thisbooleanvalue' + }, + thisNumberValue: { + url: 'https://262.ecma-international.org/12.0/#thisnumbervalue' + }, + thisStringValue: { + url: 'https://262.ecma-international.org/12.0/#thisstringvalue' + }, + thisSymbolValue: { + url: 'https://262.ecma-international.org/12.0/#thissymbolvalue' + }, + thisTimeValue: { + url: 'https://262.ecma-international.org/12.0/#thistimevalue' + }, + ThrowCompletion: { + url: 'https://262.ecma-international.org/12.0/#sec-throwcompletion' + }, + TimeClip: { + url: 'https://262.ecma-international.org/12.0/#sec-timeclip' + }, + TimeFromYear: { + url: 'https://262.ecma-international.org/12.0/#eqn-TimeFromYear' + }, + TimeString: { + url: 'https://262.ecma-international.org/12.0/#sec-timestring' + }, + TimeWithinDay: { + url: 'https://262.ecma-international.org/12.0/#eqn-TimeWithinDay' + }, + TimeZoneString: { + url: 'https://262.ecma-international.org/12.0/#sec-timezoneestring' + }, + ToBigInt: { + url: 'https://262.ecma-international.org/12.0/#sec-tobigint' + }, + ToBigInt64: { + url: 'https://262.ecma-international.org/12.0/#sec-tobigint64' + }, + ToBigUint64: { + url: 'https://262.ecma-international.org/12.0/#sec-tobiguint64' + }, + ToBoolean: { + url: 'https://262.ecma-international.org/12.0/#sec-toboolean' + }, + ToDateString: { + url: 'https://262.ecma-international.org/12.0/#sec-todatestring' + }, + ToIndex: { + url: 'https://262.ecma-international.org/12.0/#sec-toindex' + }, + ToInt16: { + url: 'https://262.ecma-international.org/12.0/#sec-toint16' + }, + ToInt32: { + url: 'https://262.ecma-international.org/12.0/#sec-toint32' + }, + ToInt8: { + url: 'https://262.ecma-international.org/12.0/#sec-toint8' + }, + ToIntegerOrInfinity: { + url: 'https://262.ecma-international.org/12.0/#sec-tointegerorinfinity' + }, + ToLength: { + url: 'https://262.ecma-international.org/12.0/#sec-tolength' + }, + ToNumber: { + url: 'https://262.ecma-international.org/12.0/#sec-tonumber' + }, + ToNumeric: { + url: 'https://262.ecma-international.org/12.0/#sec-tonumeric' + }, + ToObject: { + url: 'https://262.ecma-international.org/12.0/#sec-toobject' + }, + ToPrimitive: { + url: 'https://262.ecma-international.org/12.0/#sec-toprimitive' + }, + ToPropertyDescriptor: { + url: 'https://262.ecma-international.org/12.0/#sec-topropertydescriptor' + }, + ToPropertyKey: { + url: 'https://262.ecma-international.org/12.0/#sec-topropertykey' + }, + ToString: { + url: 'https://262.ecma-international.org/12.0/#sec-tostring' + }, + ToUint16: { + url: 'https://262.ecma-international.org/12.0/#sec-touint16' + }, + ToUint32: { + url: 'https://262.ecma-international.org/12.0/#sec-touint32' + }, + ToUint8: { + url: 'https://262.ecma-international.org/12.0/#sec-touint8' + }, + ToUint8Clamp: { + url: 'https://262.ecma-international.org/12.0/#sec-touint8clamp' + }, + TriggerPromiseReactions: { + url: 'https://262.ecma-international.org/12.0/#sec-triggerpromisereactions' + }, + TrimString: { + url: 'https://262.ecma-international.org/12.0/#sec-trimstring' + }, + Type: { + url: 'https://262.ecma-international.org/12.0/#sec-ecmascript-data-types-and-values' + }, + TypedArrayCreate: { + url: 'https://262.ecma-international.org/12.0/#typedarray-create' + }, + TypedArraySpeciesCreate: { + url: 'https://262.ecma-international.org/12.0/#typedarray-species-create' + }, + UnicodeEscape: { + url: 'https://262.ecma-international.org/12.0/#sec-unicodeescape' + }, + UnicodeMatchProperty: { + url: 'https://262.ecma-international.org/12.0/#sec-runtime-semantics-unicodematchproperty-p' + }, + UnicodeMatchPropertyValue: { + url: 'https://262.ecma-international.org/12.0/#sec-runtime-semantics-unicodematchpropertyvalue-p-v' + }, + UpdateEmpty: { + url: 'https://262.ecma-international.org/12.0/#sec-updateempty' + }, + UTC: { + url: 'https://262.ecma-international.org/12.0/#sec-utc-t' + }, + UTF16EncodeCodePoint: { + url: 'https://262.ecma-international.org/12.0/#sec-utf16encodecodepoint' + }, + UTF16SurrogatePairToCodePoint: { + url: 'https://262.ecma-international.org/12.0/#sec-utf16decodesurrogatepair' + }, + ValidateAndApplyPropertyDescriptor: { + url: 'https://262.ecma-international.org/12.0/#sec-validateandapplypropertydescriptor' + }, + ValidateAtomicAccess: { + url: 'https://262.ecma-international.org/12.0/#sec-validateatomicaccess' + }, + ValidateIntegerTypedArray: { + url: 'https://262.ecma-international.org/12.0/#sec-validateintegertypedarray' + }, + ValidateTypedArray: { + url: 'https://262.ecma-international.org/12.0/#sec-validatetypedarray' + }, + ValueOfReadEvent: { + url: 'https://262.ecma-international.org/12.0/#sec-valueofreadevent' + }, + WeakRefDeref: { + url: 'https://262.ecma-international.org/12.0/#sec-weakrefderef' + }, + WeekDay: { + url: 'https://262.ecma-international.org/12.0/#sec-week-day' + }, + WordCharacters: { + url: 'https://262.ecma-international.org/12.0/#sec-runtime-semantics-wordcharacters-abstract-operation' + }, + YearFromTime: { + url: 'https://262.ecma-international.org/12.0/#eqn-YearFromTime' + }, + Yield: { + url: 'https://262.ecma-international.org/12.0/#sec-yield' + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2022.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2022.js new file mode 100644 index 0000000000000000000000000000000000000000..f678e68ead1a3123aad026c63857a0077b22af6d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2022.js @@ -0,0 +1,1372 @@ +'use strict'; + +module.exports = { + abs: { + url: 'https://262.ecma-international.org/13.0/#eqn-abs' + }, + AddEntriesFromIterable: { + url: 'https://262.ecma-international.org/13.0/#sec-add-entries-from-iterable' + }, + AddRestrictedFunctionProperties: { + url: 'https://262.ecma-international.org/13.0/#sec-addrestrictedfunctionproperties' + }, + AddToKeptObjects: { + url: 'https://262.ecma-international.org/13.0/#sec-addtokeptobjects' + }, + AddWaiter: { + url: 'https://262.ecma-international.org/13.0/#sec-addwaiter' + }, + AdvanceStringIndex: { + url: 'https://262.ecma-international.org/13.0/#sec-advancestringindex' + }, + 'agent-order': { + url: 'https://262.ecma-international.org/13.0/#sec-agent-order' + }, + AgentCanSuspend: { + url: 'https://262.ecma-international.org/13.0/#sec-agentcansuspend' + }, + AgentSignifier: { + url: 'https://262.ecma-international.org/13.0/#sec-agentsignifier' + }, + AllocateArrayBuffer: { + url: 'https://262.ecma-international.org/13.0/#sec-allocatearraybuffer' + }, + AllocateSharedArrayBuffer: { + url: 'https://262.ecma-international.org/13.0/#sec-allocatesharedarraybuffer' + }, + AllocateTypedArray: { + url: 'https://262.ecma-international.org/13.0/#sec-allocatetypedarray' + }, + AllocateTypedArrayBuffer: { + url: 'https://262.ecma-international.org/13.0/#sec-allocatetypedarraybuffer' + }, + ApplyStringOrNumericBinaryOperator: { + url: 'https://262.ecma-international.org/13.0/#sec-applystringornumericbinaryoperator' + }, + ArrayCreate: { + url: 'https://262.ecma-international.org/13.0/#sec-arraycreate' + }, + ArraySetLength: { + url: 'https://262.ecma-international.org/13.0/#sec-arraysetlength' + }, + ArraySpeciesCreate: { + url: 'https://262.ecma-international.org/13.0/#sec-arrayspeciescreate' + }, + AsyncBlockStart: { + url: 'https://262.ecma-international.org/13.0/#sec-asyncblockstart' + }, + AsyncFromSyncIteratorContinuation: { + url: 'https://262.ecma-international.org/13.0/#sec-asyncfromsynciteratorcontinuation' + }, + AsyncFunctionStart: { + url: 'https://262.ecma-international.org/13.0/#sec-async-functions-abstract-operations-async-function-start' + }, + AsyncGeneratorAwaitReturn: { + url: 'https://262.ecma-international.org/13.0/#sec-asyncgeneratorawaitreturn' + }, + AsyncGeneratorCompleteStep: { + url: 'https://262.ecma-international.org/13.0/#sec-asyncgeneratorcompletestep' + }, + AsyncGeneratorDrainQueue: { + url: 'https://262.ecma-international.org/13.0/#sec-asyncgeneratordrainqueue' + }, + AsyncGeneratorEnqueue: { + url: 'https://262.ecma-international.org/13.0/#sec-asyncgeneratorenqueue' + }, + AsyncGeneratorResume: { + url: 'https://262.ecma-international.org/13.0/#sec-asyncgeneratorresume' + }, + AsyncGeneratorStart: { + url: 'https://262.ecma-international.org/13.0/#sec-asyncgeneratorstart' + }, + AsyncGeneratorUnwrapYieldResumption: { + url: 'https://262.ecma-international.org/13.0/#sec-asyncgeneratorunwrapyieldresumption' + }, + AsyncGeneratorValidate: { + url: 'https://262.ecma-international.org/13.0/#sec-asyncgeneratorvalidate' + }, + AsyncGeneratorYield: { + url: 'https://262.ecma-international.org/13.0/#sec-asyncgeneratoryield' + }, + AsyncIteratorClose: { + url: 'https://262.ecma-international.org/13.0/#sec-asynciteratorclose' + }, + AsyncModuleExecutionFulfilled: { + url: 'https://262.ecma-international.org/13.0/#sec-async-module-execution-fulfilled' + }, + AsyncModuleExecutionRejected: { + url: 'https://262.ecma-international.org/13.0/#sec-async-module-execution-rejected' + }, + AtomicReadModifyWrite: { + url: 'https://262.ecma-international.org/13.0/#sec-atomicreadmodifywrite' + }, + Await: { + url: 'https://262.ecma-international.org/13.0/#await' + }, + BackreferenceMatcher: { + url: 'https://262.ecma-international.org/13.0/#sec-backreference-matcher' + }, + 'BigInt::add': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-bigint-add' + }, + 'BigInt::bitwiseAND': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-bigint-bitwiseAND' + }, + 'BigInt::bitwiseNOT': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-bigint-bitwiseNOT' + }, + 'BigInt::bitwiseOR': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-bigint-bitwiseOR' + }, + 'BigInt::bitwiseXOR': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-bigint-bitwiseXOR' + }, + 'BigInt::divide': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-bigint-divide' + }, + 'BigInt::equal': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-bigint-equal' + }, + 'BigInt::exponentiate': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-bigint-exponentiate' + }, + 'BigInt::leftShift': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-bigint-leftShift' + }, + 'BigInt::lessThan': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-bigint-lessThan' + }, + 'BigInt::multiply': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-bigint-multiply' + }, + 'BigInt::remainder': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-bigint-remainder' + }, + 'BigInt::sameValue': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-bigint-sameValue' + }, + 'BigInt::sameValueZero': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-bigint-sameValueZero' + }, + 'BigInt::signedRightShift': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-bigint-signedRightShift' + }, + 'BigInt::subtract': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-bigint-subtract' + }, + 'BigInt::toString': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-bigint-tostring' + }, + 'BigInt::unaryMinus': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-bigint-unaryMinus' + }, + 'BigInt::unsignedRightShift': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-bigint-unsignedRightShift' + }, + BigIntBitwiseOp: { + url: 'https://262.ecma-international.org/13.0/#sec-bigintbitwiseop' + }, + BinaryAnd: { + url: 'https://262.ecma-international.org/13.0/#sec-binaryand' + }, + BinaryOr: { + url: 'https://262.ecma-international.org/13.0/#sec-binaryor' + }, + BinaryXor: { + url: 'https://262.ecma-international.org/13.0/#sec-binaryxor' + }, + BlockDeclarationInstantiation: { + url: 'https://262.ecma-international.org/13.0/#sec-blockdeclarationinstantiation' + }, + BoundFunctionCreate: { + url: 'https://262.ecma-international.org/13.0/#sec-boundfunctioncreate' + }, + ByteListBitwiseOp: { + url: 'https://262.ecma-international.org/13.0/#sec-bytelistbitwiseop' + }, + ByteListEqual: { + url: 'https://262.ecma-international.org/13.0/#sec-bytelistequal' + }, + Call: { + url: 'https://262.ecma-international.org/13.0/#sec-call' + }, + Canonicalize: { + url: 'https://262.ecma-international.org/13.0/#sec-runtime-semantics-canonicalize-ch' + }, + CanonicalNumericIndexString: { + url: 'https://262.ecma-international.org/13.0/#sec-canonicalnumericindexstring' + }, + CaseClauseIsSelected: { + url: 'https://262.ecma-international.org/13.0/#sec-runtime-semantics-caseclauseisselected' + }, + CharacterRange: { + url: 'https://262.ecma-international.org/13.0/#sec-runtime-semantics-characterrange-abstract-operation' + }, + CharacterRangeOrUnion: { + url: 'https://262.ecma-international.org/13.0/#sec-runtime-semantics-characterrangeorunion-abstract-operation' + }, + CharacterSetMatcher: { + url: 'https://262.ecma-international.org/13.0/#sec-runtime-semantics-charactersetmatcher-abstract-operation' + }, + clamp: { + url: 'https://262.ecma-international.org/13.0/#clamping' + }, + CleanupFinalizationRegistry: { + url: 'https://262.ecma-international.org/13.0/#sec-cleanup-finalization-registry' + }, + ClearKeptObjects: { + url: 'https://262.ecma-international.org/13.0/#sec-clear-kept-objects' + }, + CloneArrayBuffer: { + url: 'https://262.ecma-international.org/13.0/#sec-clonearraybuffer' + }, + CodePointAt: { + url: 'https://262.ecma-international.org/13.0/#sec-codepointat' + }, + CodePointsToString: { + url: 'https://262.ecma-international.org/13.0/#sec-codepointstostring' + }, + CompletePropertyDescriptor: { + url: 'https://262.ecma-international.org/13.0/#sec-completepropertydescriptor' + }, + Completion: { + url: 'https://262.ecma-international.org/13.0/#sec-completion-ao' + }, + CompletionRecord: { + url: 'https://262.ecma-international.org/13.0/#sec-completion-record-specification-type' + }, + ComposeWriteEventBytes: { + url: 'https://262.ecma-international.org/13.0/#sec-composewriteeventbytes' + }, + Construct: { + url: 'https://262.ecma-international.org/13.0/#sec-construct' + }, + CopyDataBlockBytes: { + url: 'https://262.ecma-international.org/13.0/#sec-copydatablockbytes' + }, + CopyDataProperties: { + url: 'https://262.ecma-international.org/13.0/#sec-copydataproperties' + }, + CreateArrayFromList: { + url: 'https://262.ecma-international.org/13.0/#sec-createarrayfromlist' + }, + CreateArrayIterator: { + url: 'https://262.ecma-international.org/13.0/#sec-createarrayiterator' + }, + CreateAsyncFromSyncIterator: { + url: 'https://262.ecma-international.org/13.0/#sec-createasyncfromsynciterator' + }, + CreateAsyncIteratorFromClosure: { + url: 'https://262.ecma-international.org/13.0/#sec-createasynciteratorfromclosure' + }, + CreateBuiltinFunction: { + url: 'https://262.ecma-international.org/13.0/#sec-createbuiltinfunction' + }, + CreateByteDataBlock: { + url: 'https://262.ecma-international.org/13.0/#sec-createbytedatablock' + }, + CreateDataProperty: { + url: 'https://262.ecma-international.org/13.0/#sec-createdataproperty' + }, + CreateDataPropertyOrThrow: { + url: 'https://262.ecma-international.org/13.0/#sec-createdatapropertyorthrow' + }, + CreateDynamicFunction: { + url: 'https://262.ecma-international.org/13.0/#sec-createdynamicfunction' + }, + CreateForInIterator: { + url: 'https://262.ecma-international.org/13.0/#sec-createforiniterator' + }, + CreateHTML: { + url: 'https://262.ecma-international.org/13.0/#sec-createhtml' + }, + CreateIntrinsics: { + url: 'https://262.ecma-international.org/13.0/#sec-createintrinsics' + }, + CreateIteratorFromClosure: { + url: 'https://262.ecma-international.org/13.0/#sec-createiteratorfromclosure' + }, + CreateIterResultObject: { + url: 'https://262.ecma-international.org/13.0/#sec-createiterresultobject' + }, + CreateListFromArrayLike: { + url: 'https://262.ecma-international.org/13.0/#sec-createlistfromarraylike' + }, + CreateListIteratorRecord: { + url: 'https://262.ecma-international.org/13.0/#sec-createlistiteratorRecord' + }, + CreateMapIterator: { + url: 'https://262.ecma-international.org/13.0/#sec-createmapiterator' + }, + CreateMappedArgumentsObject: { + url: 'https://262.ecma-international.org/13.0/#sec-createmappedargumentsobject' + }, + CreateMethodProperty: { + url: 'https://262.ecma-international.org/13.0/#sec-createmethodproperty' + }, + CreateNonEnumerableDataPropertyOrThrow: { + url: 'https://262.ecma-international.org/13.0/#sec-createnonenumerabledatapropertyorthrow' + }, + CreatePerIterationEnvironment: { + url: 'https://262.ecma-international.org/13.0/#sec-createperiterationenvironment' + }, + CreateRealm: { + url: 'https://262.ecma-international.org/13.0/#sec-createrealm' + }, + CreateRegExpStringIterator: { + url: 'https://262.ecma-international.org/13.0/#sec-createregexpstringiterator' + }, + CreateResolvingFunctions: { + url: 'https://262.ecma-international.org/13.0/#sec-createresolvingfunctions' + }, + CreateSetIterator: { + url: 'https://262.ecma-international.org/13.0/#sec-createsetiterator' + }, + CreateSharedByteDataBlock: { + url: 'https://262.ecma-international.org/13.0/#sec-createsharedbytedatablock' + }, + CreateUnmappedArgumentsObject: { + url: 'https://262.ecma-international.org/13.0/#sec-createunmappedargumentsobject' + }, + DateFromTime: { + url: 'https://262.ecma-international.org/13.0/#sec-date-number' + }, + DateString: { + url: 'https://262.ecma-international.org/13.0/#sec-datestring' + }, + Day: { + url: 'https://262.ecma-international.org/13.0/#eqn-Day' + }, + DayFromYear: { + url: 'https://262.ecma-international.org/13.0/#eqn-DaysFromYear' + }, + DaysInYear: { + url: 'https://262.ecma-international.org/13.0/#eqn-DaysInYear' + }, + DayWithinYear: { + url: 'https://262.ecma-international.org/13.0/#eqn-DayWithinYear' + }, + Decode: { + url: 'https://262.ecma-international.org/13.0/#sec-decode' + }, + DefineField: { + url: 'https://262.ecma-international.org/13.0/#sec-definefield' + }, + DefineMethodProperty: { + url: 'https://262.ecma-international.org/13.0/#sec-definemethodproperty' + }, + DefinePropertyOrThrow: { + url: 'https://262.ecma-international.org/13.0/#sec-definepropertyorthrow' + }, + DeletePropertyOrThrow: { + url: 'https://262.ecma-international.org/13.0/#sec-deletepropertyorthrow' + }, + DetachArrayBuffer: { + url: 'https://262.ecma-international.org/13.0/#sec-detacharraybuffer' + }, + Encode: { + url: 'https://262.ecma-international.org/13.0/#sec-encode' + }, + EnterCriticalSection: { + url: 'https://262.ecma-international.org/13.0/#sec-entercriticalsection' + }, + EnumerableOwnPropertyNames: { + url: 'https://262.ecma-international.org/13.0/#sec-enumerableownpropertynames' + }, + EnumerateObjectProperties: { + url: 'https://262.ecma-international.org/13.0/#sec-enumerate-object-properties' + }, + EscapeRegExpPattern: { + url: 'https://262.ecma-international.org/13.0/#sec-escaperegexppattern' + }, + EvalDeclarationInstantiation: { + url: 'https://262.ecma-international.org/13.0/#sec-evaldeclarationinstantiation' + }, + EvaluateCall: { + url: 'https://262.ecma-international.org/13.0/#sec-evaluatecall' + }, + EvaluateNew: { + url: 'https://262.ecma-international.org/13.0/#sec-evaluatenew' + }, + EvaluatePropertyAccessWithExpressionKey: { + url: 'https://262.ecma-international.org/13.0/#sec-evaluate-property-access-with-expression-key' + }, + EvaluatePropertyAccessWithIdentifierKey: { + url: 'https://262.ecma-international.org/13.0/#sec-evaluate-property-access-with-identifier-key' + }, + EvaluateStringOrNumericBinaryExpression: { + url: 'https://262.ecma-international.org/13.0/#sec-evaluatestringornumericbinaryexpression' + }, + EventSet: { + url: 'https://262.ecma-international.org/13.0/#sec-event-set' + }, + ExecuteAsyncModule: { + url: 'https://262.ecma-international.org/13.0/#sec-execute-async-module' + }, + FinishDynamicImport: { + url: 'https://262.ecma-international.org/13.0/#sec-finishdynamicimport' + }, + FlattenIntoArray: { + url: 'https://262.ecma-international.org/13.0/#sec-flattenintoarray' + }, + floor: { + url: 'https://262.ecma-international.org/13.0/#eqn-floor' + }, + ForBodyEvaluation: { + url: 'https://262.ecma-international.org/13.0/#sec-forbodyevaluation' + }, + 'ForIn/OfBodyEvaluation': { + url: 'https://262.ecma-international.org/13.0/#sec-runtime-semantics-forin-div-ofbodyevaluation-lhs-stmt-iterator-lhskind-labelset' + }, + 'ForIn/OfHeadEvaluation': { + url: 'https://262.ecma-international.org/13.0/#sec-runtime-semantics-forinofheadevaluation' + }, + FromPropertyDescriptor: { + url: 'https://262.ecma-international.org/13.0/#sec-frompropertydescriptor' + }, + FulfillPromise: { + url: 'https://262.ecma-international.org/13.0/#sec-fulfillpromise' + }, + FunctionDeclarationInstantiation: { + url: 'https://262.ecma-international.org/13.0/#sec-functiondeclarationinstantiation' + }, + GatherAvailableAncestors: { + url: 'https://262.ecma-international.org/13.0/#sec-gather-available-ancestors' + }, + GeneratorResume: { + url: 'https://262.ecma-international.org/13.0/#sec-generatorresume' + }, + GeneratorResumeAbrupt: { + url: 'https://262.ecma-international.org/13.0/#sec-generatorresumeabrupt' + }, + GeneratorStart: { + url: 'https://262.ecma-international.org/13.0/#sec-generatorstart' + }, + GeneratorValidate: { + url: 'https://262.ecma-international.org/13.0/#sec-generatorvalidate' + }, + GeneratorYield: { + url: 'https://262.ecma-international.org/13.0/#sec-generatoryield' + }, + Get: { + url: 'https://262.ecma-international.org/13.0/#sec-get-o-p' + }, + GetActiveScriptOrModule: { + url: 'https://262.ecma-international.org/13.0/#sec-getactivescriptormodule' + }, + GetFunctionRealm: { + url: 'https://262.ecma-international.org/13.0/#sec-getfunctionrealm' + }, + GetGeneratorKind: { + url: 'https://262.ecma-international.org/13.0/#sec-getgeneratorkind' + }, + GetGlobalObject: { + url: 'https://262.ecma-international.org/13.0/#sec-getglobalobject' + }, + GetIdentifierReference: { + url: 'https://262.ecma-international.org/13.0/#sec-getidentifierreference' + }, + GetIterator: { + url: 'https://262.ecma-international.org/13.0/#sec-getiterator' + }, + GetMatchIndexPair: { + url: 'https://262.ecma-international.org/13.0/#sec-getmatchindexpair' + }, + GetMatchString: { + url: 'https://262.ecma-international.org/13.0/#sec-getmatchstring' + }, + GetMethod: { + url: 'https://262.ecma-international.org/13.0/#sec-getmethod' + }, + GetModifySetValueInBuffer: { + url: 'https://262.ecma-international.org/13.0/#sec-getmodifysetvalueinbuffer' + }, + GetModuleNamespace: { + url: 'https://262.ecma-international.org/13.0/#sec-getmodulenamespace' + }, + GetNewTarget: { + url: 'https://262.ecma-international.org/13.0/#sec-getnewtarget' + }, + GetOwnPropertyKeys: { + url: 'https://262.ecma-international.org/13.0/#sec-getownpropertykeys' + }, + GetPromiseResolve: { + url: 'https://262.ecma-international.org/13.0/#sec-getpromiseresolve' + }, + GetPrototypeFromConstructor: { + url: 'https://262.ecma-international.org/13.0/#sec-getprototypefromconstructor' + }, + GetStringIndex: { + url: 'https://262.ecma-international.org/13.0/#sec-getstringindex' + }, + GetSubstitution: { + url: 'https://262.ecma-international.org/13.0/#sec-getsubstitution' + }, + GetSuperConstructor: { + url: 'https://262.ecma-international.org/13.0/#sec-getsuperconstructor' + }, + GetTemplateObject: { + url: 'https://262.ecma-international.org/13.0/#sec-gettemplateobject' + }, + GetThisEnvironment: { + url: 'https://262.ecma-international.org/13.0/#sec-getthisenvironment' + }, + GetThisValue: { + url: 'https://262.ecma-international.org/13.0/#sec-getthisvalue' + }, + GetV: { + url: 'https://262.ecma-international.org/13.0/#sec-getv' + }, + GetValue: { + url: 'https://262.ecma-international.org/13.0/#sec-getvalue' + }, + GetValueFromBuffer: { + url: 'https://262.ecma-international.org/13.0/#sec-getvaluefrombuffer' + }, + GetViewValue: { + url: 'https://262.ecma-international.org/13.0/#sec-getviewvalue' + }, + GetWaiterList: { + url: 'https://262.ecma-international.org/13.0/#sec-getwaiterlist' + }, + GlobalDeclarationInstantiation: { + url: 'https://262.ecma-international.org/13.0/#sec-globaldeclarationinstantiation' + }, + 'happens-before': { + url: 'https://262.ecma-international.org/13.0/#sec-happens-before' + }, + HasOwnProperty: { + url: 'https://262.ecma-international.org/13.0/#sec-hasownproperty' + }, + HasProperty: { + url: 'https://262.ecma-international.org/13.0/#sec-hasproperty' + }, + 'host-synchronizes-with': { + url: 'https://262.ecma-international.org/13.0/#sec-host-synchronizes-with' + }, + HostEventSet: { + url: 'https://262.ecma-international.org/13.0/#sec-hosteventset' + }, + HourFromTime: { + url: 'https://262.ecma-international.org/13.0/#eqn-HourFromTime' + }, + IfAbruptCloseIterator: { + url: 'https://262.ecma-international.org/13.0/#sec-ifabruptcloseiterator' + }, + IfAbruptRejectPromise: { + url: 'https://262.ecma-international.org/13.0/#sec-ifabruptrejectpromise' + }, + ImportedLocalNames: { + url: 'https://262.ecma-international.org/13.0/#sec-importedlocalnames' + }, + InitializeBoundName: { + url: 'https://262.ecma-international.org/13.0/#sec-initializeboundname' + }, + InitializeHostDefinedRealm: { + url: 'https://262.ecma-international.org/13.0/#sec-initializehostdefinedrealm' + }, + InitializeInstanceElements: { + url: 'https://262.ecma-international.org/13.0/#sec-initializeinstanceelements' + }, + InitializeReferencedBinding: { + url: 'https://262.ecma-international.org/13.0/#sec-initializereferencedbinding' + }, + InitializeTypedArrayFromArrayBuffer: { + url: 'https://262.ecma-international.org/13.0/#sec-initializetypedarrayfromarraybuffer' + }, + InitializeTypedArrayFromArrayLike: { + url: 'https://262.ecma-international.org/13.0/#sec-initializetypedarrayfromarraylike' + }, + InitializeTypedArrayFromList: { + url: 'https://262.ecma-international.org/13.0/#sec-initializetypedarrayfromlist' + }, + InitializeTypedArrayFromTypedArray: { + url: 'https://262.ecma-international.org/13.0/#sec-initializetypedarrayfromtypedarray' + }, + InLeapYear: { + url: 'https://262.ecma-international.org/13.0/#eqn-InLeapYear' + }, + InnerModuleEvaluation: { + url: 'https://262.ecma-international.org/13.0/#sec-innermoduleevaluation' + }, + InnerModuleLinking: { + url: 'https://262.ecma-international.org/13.0/#sec-InnerModuleLinking' + }, + InstallErrorCause: { + url: 'https://262.ecma-international.org/13.0/#sec-installerrorcause' + }, + InstanceofOperator: { + url: 'https://262.ecma-international.org/13.0/#sec-instanceofoperator' + }, + IntegerIndexedElementGet: { + url: 'https://262.ecma-international.org/13.0/#sec-integerindexedelementget' + }, + IntegerIndexedElementSet: { + url: 'https://262.ecma-international.org/13.0/#sec-integerindexedelementset' + }, + IntegerIndexedObjectCreate: { + url: 'https://262.ecma-international.org/13.0/#sec-integerindexedobjectcreate' + }, + InternalizeJSONProperty: { + url: 'https://262.ecma-international.org/13.0/#sec-internalizejsonproperty' + }, + Invoke: { + url: 'https://262.ecma-international.org/13.0/#sec-invoke' + }, + IsAccessorDescriptor: { + url: 'https://262.ecma-international.org/13.0/#sec-isaccessordescriptor' + }, + IsAnonymousFunctionDefinition: { + url: 'https://262.ecma-international.org/13.0/#sec-isanonymousfunctiondefinition' + }, + IsArray: { + url: 'https://262.ecma-international.org/13.0/#sec-isarray' + }, + IsBigIntElementType: { + url: 'https://262.ecma-international.org/13.0/#sec-isbigintelementtype' + }, + IsCallable: { + url: 'https://262.ecma-international.org/13.0/#sec-iscallable' + }, + IsCompatiblePropertyDescriptor: { + url: 'https://262.ecma-international.org/13.0/#sec-iscompatiblepropertydescriptor' + }, + IsConcatSpreadable: { + url: 'https://262.ecma-international.org/13.0/#sec-isconcatspreadable' + }, + IsConstructor: { + url: 'https://262.ecma-international.org/13.0/#sec-isconstructor' + }, + IsDataDescriptor: { + url: 'https://262.ecma-international.org/13.0/#sec-isdatadescriptor' + }, + IsDetachedBuffer: { + url: 'https://262.ecma-international.org/13.0/#sec-isdetachedbuffer' + }, + IsExtensible: { + url: 'https://262.ecma-international.org/13.0/#sec-isextensible-o' + }, + IsGenericDescriptor: { + url: 'https://262.ecma-international.org/13.0/#sec-isgenericdescriptor' + }, + IsInTailPosition: { + url: 'https://262.ecma-international.org/13.0/#sec-isintailposition' + }, + IsIntegralNumber: { + url: 'https://262.ecma-international.org/13.0/#sec-isintegralnumber' + }, + IsLabelledFunction: { + url: 'https://262.ecma-international.org/13.0/#sec-islabelledfunction' + }, + IsLessThan: { + url: 'https://262.ecma-international.org/13.0/#sec-islessthan' + }, + IsLooselyEqual: { + url: 'https://262.ecma-international.org/13.0/#sec-islooselyequal' + }, + IsNoTearConfiguration: { + url: 'https://262.ecma-international.org/13.0/#sec-isnotearconfiguration' + }, + IsPrivateReference: { + url: 'https://262.ecma-international.org/13.0/#sec-isprivatereference' + }, + IsPromise: { + url: 'https://262.ecma-international.org/13.0/#sec-ispromise' + }, + IsPropertyKey: { + url: 'https://262.ecma-international.org/13.0/#sec-ispropertykey' + }, + IsPropertyReference: { + url: 'https://262.ecma-international.org/13.0/#sec-ispropertyreference' + }, + IsRegExp: { + url: 'https://262.ecma-international.org/13.0/#sec-isregexp' + }, + IsSharedArrayBuffer: { + url: 'https://262.ecma-international.org/13.0/#sec-issharedarraybuffer' + }, + IsStrictlyEqual: { + url: 'https://262.ecma-international.org/13.0/#sec-isstrictlyequal' + }, + IsStringPrefix: { + url: 'https://262.ecma-international.org/13.0/#sec-isstringprefix' + }, + IsStringWellFormedUnicode: { + url: 'https://262.ecma-international.org/13.0/#sec-isstringwellformedunicode' + }, + IsSuperReference: { + url: 'https://262.ecma-international.org/13.0/#sec-issuperreference' + }, + IsUnclampedIntegerElementType: { + url: 'https://262.ecma-international.org/13.0/#sec-isunclampedintegerelementtype' + }, + IsUnresolvableReference: { + url: 'https://262.ecma-international.org/13.0/#sec-isunresolvablereference' + }, + IsUnsignedElementType: { + url: 'https://262.ecma-international.org/13.0/#sec-isunsignedelementtype' + }, + IsValidIntegerIndex: { + url: 'https://262.ecma-international.org/13.0/#sec-isvalidintegerindex' + }, + IsValidRegularExpressionLiteral: { + url: 'https://262.ecma-international.org/13.0/#sec-isvalidregularexpressionliteral' + }, + IsWordChar: { + url: 'https://262.ecma-international.org/13.0/#sec-runtime-semantics-iswordchar-abstract-operation' + }, + IterableToList: { + url: 'https://262.ecma-international.org/13.0/#sec-iterabletolist' + }, + IteratorClose: { + url: 'https://262.ecma-international.org/13.0/#sec-iteratorclose' + }, + IteratorComplete: { + url: 'https://262.ecma-international.org/13.0/#sec-iteratorcomplete' + }, + IteratorNext: { + url: 'https://262.ecma-international.org/13.0/#sec-iteratornext' + }, + IteratorStep: { + url: 'https://262.ecma-international.org/13.0/#sec-iteratorstep' + }, + IteratorValue: { + url: 'https://262.ecma-international.org/13.0/#sec-iteratorvalue' + }, + LeaveCriticalSection: { + url: 'https://262.ecma-international.org/13.0/#sec-leavecriticalsection' + }, + LengthOfArrayLike: { + url: 'https://262.ecma-international.org/13.0/#sec-lengthofarraylike' + }, + LocalTime: { + url: 'https://262.ecma-international.org/13.0/#sec-localtime' + }, + LocalTZA: { + url: 'https://262.ecma-international.org/13.0/#sec-local-time-zone-adjustment' + }, + LoopContinues: { + url: 'https://262.ecma-international.org/13.0/#sec-loopcontinues' + }, + MakeArgGetter: { + url: 'https://262.ecma-international.org/13.0/#sec-makearggetter' + }, + MakeArgSetter: { + url: 'https://262.ecma-international.org/13.0/#sec-makeargsetter' + }, + MakeBasicObject: { + url: 'https://262.ecma-international.org/13.0/#sec-makebasicobject' + }, + MakeClassConstructor: { + url: 'https://262.ecma-international.org/13.0/#sec-makeclassconstructor' + }, + MakeConstructor: { + url: 'https://262.ecma-international.org/13.0/#sec-makeconstructor' + }, + MakeDate: { + url: 'https://262.ecma-international.org/13.0/#sec-makedate' + }, + MakeDay: { + url: 'https://262.ecma-international.org/13.0/#sec-makeday' + }, + MakeMatchIndicesIndexPairArray: { + url: 'https://262.ecma-international.org/13.0/#sec-makematchindicesindexpairarray' + }, + MakeMethod: { + url: 'https://262.ecma-international.org/13.0/#sec-makemethod' + }, + MakePrivateReference: { + url: 'https://262.ecma-international.org/13.0/#sec-makeprivatereference' + }, + MakeSuperPropertyReference: { + url: 'https://262.ecma-international.org/13.0/#sec-makesuperpropertyreference' + }, + MakeTime: { + url: 'https://262.ecma-international.org/13.0/#sec-maketime' + }, + max: { + url: 'https://262.ecma-international.org/13.0/#eqn-max' + }, + 'memory-order': { + url: 'https://262.ecma-international.org/13.0/#sec-memory-order' + }, + min: { + url: 'https://262.ecma-international.org/13.0/#eqn-min' + }, + MinFromTime: { + url: 'https://262.ecma-international.org/13.0/#eqn-MinFromTime' + }, + ModuleNamespaceCreate: { + url: 'https://262.ecma-international.org/13.0/#sec-modulenamespacecreate' + }, + modulo: { + url: 'https://262.ecma-international.org/13.0/#eqn-modulo' + }, + MonthFromTime: { + url: 'https://262.ecma-international.org/13.0/#eqn-MonthFromTime' + }, + msFromTime: { + url: 'https://262.ecma-international.org/13.0/#eqn-msFromTime' + }, + NewDeclarativeEnvironment: { + url: 'https://262.ecma-international.org/13.0/#sec-newdeclarativeenvironment' + }, + NewFunctionEnvironment: { + url: 'https://262.ecma-international.org/13.0/#sec-newfunctionenvironment' + }, + NewGlobalEnvironment: { + url: 'https://262.ecma-international.org/13.0/#sec-newglobalenvironment' + }, + NewModuleEnvironment: { + url: 'https://262.ecma-international.org/13.0/#sec-newmoduleenvironment' + }, + NewObjectEnvironment: { + url: 'https://262.ecma-international.org/13.0/#sec-newobjectenvironment' + }, + NewPrivateEnvironment: { + url: 'https://262.ecma-international.org/13.0/#sec-newprivateenvironment' + }, + NewPromiseCapability: { + url: 'https://262.ecma-international.org/13.0/#sec-newpromisecapability' + }, + NewPromiseReactionJob: { + url: 'https://262.ecma-international.org/13.0/#sec-newpromisereactionjob' + }, + NewPromiseResolveThenableJob: { + url: 'https://262.ecma-international.org/13.0/#sec-newpromiseresolvethenablejob' + }, + NormalCompletion: { + url: 'https://262.ecma-international.org/13.0/#sec-normalcompletion' + }, + NotifyWaiter: { + url: 'https://262.ecma-international.org/13.0/#sec-notifywaiter' + }, + 'Number::add': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-number-add' + }, + 'Number::bitwiseAND': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-number-bitwiseAND' + }, + 'Number::bitwiseNOT': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-number-bitwiseNOT' + }, + 'Number::bitwiseOR': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-number-bitwiseOR' + }, + 'Number::bitwiseXOR': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-number-bitwiseXOR' + }, + 'Number::divide': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-number-divide' + }, + 'Number::equal': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-number-equal' + }, + 'Number::exponentiate': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-number-exponentiate' + }, + 'Number::leftShift': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-number-leftShift' + }, + 'Number::lessThan': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-number-lessThan' + }, + 'Number::multiply': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-number-multiply' + }, + 'Number::remainder': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-number-remainder' + }, + 'Number::sameValue': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-number-sameValue' + }, + 'Number::sameValueZero': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-number-sameValueZero' + }, + 'Number::signedRightShift': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-number-signedRightShift' + }, + 'Number::subtract': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-number-subtract' + }, + 'Number::toString': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-number-tostring' + }, + 'Number::unaryMinus': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-number-unaryMinus' + }, + 'Number::unsignedRightShift': { + url: 'https://262.ecma-international.org/13.0/#sec-numeric-types-number-unsignedRightShift' + }, + NumberBitwiseOp: { + url: 'https://262.ecma-international.org/13.0/#sec-numberbitwiseop' + }, + NumberToBigInt: { + url: 'https://262.ecma-international.org/13.0/#sec-numbertobigint' + }, + NumericToRawBytes: { + url: 'https://262.ecma-international.org/13.0/#sec-numerictorawbytes' + }, + ObjectDefineProperties: { + url: 'https://262.ecma-international.org/13.0/#sec-objectdefineproperties' + }, + OrdinaryCallBindThis: { + url: 'https://262.ecma-international.org/13.0/#sec-ordinarycallbindthis' + }, + OrdinaryCallEvaluateBody: { + url: 'https://262.ecma-international.org/13.0/#sec-ordinarycallevaluatebody' + }, + OrdinaryCreateFromConstructor: { + url: 'https://262.ecma-international.org/13.0/#sec-ordinarycreatefromconstructor' + }, + OrdinaryDefineOwnProperty: { + url: 'https://262.ecma-international.org/13.0/#sec-ordinarydefineownproperty' + }, + OrdinaryDelete: { + url: 'https://262.ecma-international.org/13.0/#sec-ordinarydelete' + }, + OrdinaryFunctionCreate: { + url: 'https://262.ecma-international.org/13.0/#sec-ordinaryfunctioncreate' + }, + OrdinaryGet: { + url: 'https://262.ecma-international.org/13.0/#sec-ordinaryget' + }, + OrdinaryGetOwnProperty: { + url: 'https://262.ecma-international.org/13.0/#sec-ordinarygetownproperty' + }, + OrdinaryGetPrototypeOf: { + url: 'https://262.ecma-international.org/13.0/#sec-ordinarygetprototypeof' + }, + OrdinaryHasInstance: { + url: 'https://262.ecma-international.org/13.0/#sec-ordinaryhasinstance' + }, + OrdinaryHasProperty: { + url: 'https://262.ecma-international.org/13.0/#sec-ordinaryhasproperty' + }, + OrdinaryIsExtensible: { + url: 'https://262.ecma-international.org/13.0/#sec-ordinaryisextensible' + }, + OrdinaryObjectCreate: { + url: 'https://262.ecma-international.org/13.0/#sec-ordinaryobjectcreate' + }, + OrdinaryOwnPropertyKeys: { + url: 'https://262.ecma-international.org/13.0/#sec-ordinaryownpropertykeys' + }, + OrdinaryPreventExtensions: { + url: 'https://262.ecma-international.org/13.0/#sec-ordinarypreventextensions' + }, + OrdinarySet: { + url: 'https://262.ecma-international.org/13.0/#sec-ordinaryset' + }, + OrdinarySetPrototypeOf: { + url: 'https://262.ecma-international.org/13.0/#sec-ordinarysetprototypeof' + }, + OrdinarySetWithOwnDescriptor: { + url: 'https://262.ecma-international.org/13.0/#sec-ordinarysetwithowndescriptor' + }, + OrdinaryToPrimitive: { + url: 'https://262.ecma-international.org/13.0/#sec-ordinarytoprimitive' + }, + ParseModule: { + url: 'https://262.ecma-international.org/13.0/#sec-parsemodule' + }, + ParsePattern: { + url: 'https://262.ecma-international.org/13.0/#sec-parsepattern' + }, + ParseScript: { + url: 'https://262.ecma-international.org/13.0/#sec-parse-script' + }, + ParseText: { + url: 'https://262.ecma-international.org/13.0/#sec-parsetext' + }, + PerformEval: { + url: 'https://262.ecma-international.org/13.0/#sec-performeval' + }, + PerformPromiseAll: { + url: 'https://262.ecma-international.org/13.0/#sec-performpromiseall' + }, + PerformPromiseAllSettled: { + url: 'https://262.ecma-international.org/13.0/#sec-performpromiseallsettled' + }, + PerformPromiseAny: { + url: 'https://262.ecma-international.org/13.0/#sec-performpromiseany' + }, + PerformPromiseRace: { + url: 'https://262.ecma-international.org/13.0/#sec-performpromiserace' + }, + PerformPromiseThen: { + url: 'https://262.ecma-international.org/13.0/#sec-performpromisethen' + }, + PrepareForOrdinaryCall: { + url: 'https://262.ecma-international.org/13.0/#sec-prepareforordinarycall' + }, + PrepareForTailCall: { + url: 'https://262.ecma-international.org/13.0/#sec-preparefortailcall' + }, + PrivateElementFind: { + url: 'https://262.ecma-international.org/13.0/#sec-privateelementfind' + }, + PrivateFieldAdd: { + url: 'https://262.ecma-international.org/13.0/#sec-privatefieldadd' + }, + PrivateGet: { + url: 'https://262.ecma-international.org/13.0/#sec-privateget' + }, + PrivateMethodOrAccessorAdd: { + url: 'https://262.ecma-international.org/13.0/#sec-privatemethodoraccessoradd' + }, + PrivateSet: { + url: 'https://262.ecma-international.org/13.0/#sec-privateset' + }, + PromiseResolve: { + url: 'https://262.ecma-international.org/13.0/#sec-promise-resolve' + }, + ProxyCreate: { + url: 'https://262.ecma-international.org/13.0/#sec-proxycreate' + }, + PutValue: { + url: 'https://262.ecma-international.org/13.0/#sec-putvalue' + }, + QuoteJSONString: { + url: 'https://262.ecma-international.org/13.0/#sec-quotejsonstring' + }, + RawBytesToNumeric: { + url: 'https://262.ecma-international.org/13.0/#sec-rawbytestonumeric' + }, + 'reads-bytes-from': { + url: 'https://262.ecma-international.org/13.0/#sec-reads-bytes-from' + }, + 'reads-from': { + url: 'https://262.ecma-international.org/13.0/#sec-reads-from' + }, + RegExpAlloc: { + url: 'https://262.ecma-international.org/13.0/#sec-regexpalloc' + }, + RegExpBuiltinExec: { + url: 'https://262.ecma-international.org/13.0/#sec-regexpbuiltinexec' + }, + RegExpCreate: { + url: 'https://262.ecma-international.org/13.0/#sec-regexpcreate' + }, + RegExpExec: { + url: 'https://262.ecma-international.org/13.0/#sec-regexpexec' + }, + RegExpHasFlag: { + url: 'https://262.ecma-international.org/13.0/#sec-regexphasflag' + }, + RegExpInitialize: { + url: 'https://262.ecma-international.org/13.0/#sec-regexpinitialize' + }, + RejectPromise: { + url: 'https://262.ecma-international.org/13.0/#sec-rejectpromise' + }, + RemoveWaiter: { + url: 'https://262.ecma-international.org/13.0/#sec-removewaiter' + }, + RemoveWaiters: { + url: 'https://262.ecma-international.org/13.0/#sec-removewaiters' + }, + RepeatMatcher: { + url: 'https://262.ecma-international.org/13.0/#sec-runtime-semantics-repeatmatcher-abstract-operation' + }, + RequireInternalSlot: { + url: 'https://262.ecma-international.org/13.0/#sec-requireinternalslot' + }, + RequireObjectCoercible: { + url: 'https://262.ecma-international.org/13.0/#sec-requireobjectcoercible' + }, + ResolveBinding: { + url: 'https://262.ecma-international.org/13.0/#sec-resolvebinding' + }, + ResolvePrivateIdentifier: { + url: 'https://262.ecma-international.org/13.0/#sec-resolve-private-identifier' + }, + ResolveThisBinding: { + url: 'https://262.ecma-international.org/13.0/#sec-resolvethisbinding' + }, + ReturnIfAbrupt: { + url: 'https://262.ecma-international.org/13.0/#sec-returnifabrupt' + }, + RoundMVResult: { + url: 'https://262.ecma-international.org/13.0/#sec-roundmvresult' + }, + SameValue: { + url: 'https://262.ecma-international.org/13.0/#sec-samevalue' + }, + SameValueNonNumeric: { + url: 'https://262.ecma-international.org/13.0/#sec-samevaluenonnumeric' + }, + SameValueZero: { + url: 'https://262.ecma-international.org/13.0/#sec-samevaluezero' + }, + ScriptEvaluation: { + url: 'https://262.ecma-international.org/13.0/#sec-runtime-semantics-scriptevaluation' + }, + SecFromTime: { + url: 'https://262.ecma-international.org/13.0/#eqn-SecFromTime' + }, + SerializeJSONArray: { + url: 'https://262.ecma-international.org/13.0/#sec-serializejsonarray' + }, + SerializeJSONObject: { + url: 'https://262.ecma-international.org/13.0/#sec-serializejsonobject' + }, + SerializeJSONProperty: { + url: 'https://262.ecma-international.org/13.0/#sec-serializejsonproperty' + }, + Set: { + url: 'https://262.ecma-international.org/13.0/#sec-set-o-p-v-throw' + }, + SetDefaultGlobalBindings: { + url: 'https://262.ecma-international.org/13.0/#sec-setdefaultglobalbindings' + }, + SetFunctionLength: { + url: 'https://262.ecma-international.org/13.0/#sec-setfunctionlength' + }, + SetFunctionName: { + url: 'https://262.ecma-international.org/13.0/#sec-setfunctionname' + }, + SetImmutablePrototype: { + url: 'https://262.ecma-international.org/13.0/#sec-set-immutable-prototype' + }, + SetIntegrityLevel: { + url: 'https://262.ecma-international.org/13.0/#sec-setintegritylevel' + }, + SetRealmGlobalObject: { + url: 'https://262.ecma-international.org/13.0/#sec-setrealmglobalobject' + }, + SetTypedArrayFromArrayLike: { + url: 'https://262.ecma-international.org/13.0/#sec-settypedarrayfromarraylike' + }, + SetTypedArrayFromTypedArray: { + url: 'https://262.ecma-international.org/13.0/#sec-settypedarrayfromtypedarray' + }, + SetValueInBuffer: { + url: 'https://262.ecma-international.org/13.0/#sec-setvalueinbuffer' + }, + SetViewValue: { + url: 'https://262.ecma-international.org/13.0/#sec-setviewvalue' + }, + SharedDataBlockEventSet: { + url: 'https://262.ecma-international.org/13.0/#sec-sharedatablockeventset' + }, + SortIndexedProperties: { + url: 'https://262.ecma-international.org/13.0/#sec-sortindexedproperties' + }, + SpeciesConstructor: { + url: 'https://262.ecma-international.org/13.0/#sec-speciesconstructor' + }, + StringCreate: { + url: 'https://262.ecma-international.org/13.0/#sec-stringcreate' + }, + StringGetOwnProperty: { + url: 'https://262.ecma-international.org/13.0/#sec-stringgetownproperty' + }, + StringIndexOf: { + url: 'https://262.ecma-international.org/13.0/#sec-stringindexof' + }, + StringPad: { + url: 'https://262.ecma-international.org/13.0/#sec-stringpad' + }, + StringToBigInt: { + url: 'https://262.ecma-international.org/13.0/#sec-stringtobigint' + }, + StringToCodePoints: { + url: 'https://262.ecma-international.org/13.0/#sec-stringtocodepoints' + }, + StringToNumber: { + url: 'https://262.ecma-international.org/13.0/#sec-stringtonumber' + }, + substring: { + url: 'https://262.ecma-international.org/13.0/#substring' + }, + SuspendAgent: { + url: 'https://262.ecma-international.org/13.0/#sec-suspendagent' + }, + SymbolDescriptiveString: { + url: 'https://262.ecma-international.org/13.0/#sec-symboldescriptivestring' + }, + 'synchronizes-with': { + url: 'https://262.ecma-international.org/13.0/#sec-synchronizes-with' + }, + TestIntegrityLevel: { + url: 'https://262.ecma-international.org/13.0/#sec-testintegritylevel' + }, + thisBigIntValue: { + url: 'https://262.ecma-international.org/13.0/#thisbigintvalue' + }, + thisBooleanValue: { + url: 'https://262.ecma-international.org/13.0/#thisbooleanvalue' + }, + thisNumberValue: { + url: 'https://262.ecma-international.org/13.0/#thisnumbervalue' + }, + thisStringValue: { + url: 'https://262.ecma-international.org/13.0/#thisstringvalue' + }, + thisSymbolValue: { + url: 'https://262.ecma-international.org/13.0/#thissymbolvalue' + }, + thisTimeValue: { + url: 'https://262.ecma-international.org/13.0/#thistimevalue' + }, + ThrowCompletion: { + url: 'https://262.ecma-international.org/13.0/#sec-throwcompletion' + }, + TimeClip: { + url: 'https://262.ecma-international.org/13.0/#sec-timeclip' + }, + TimeFromYear: { + url: 'https://262.ecma-international.org/13.0/#eqn-TimeFromYear' + }, + TimeString: { + url: 'https://262.ecma-international.org/13.0/#sec-timestring' + }, + TimeWithinDay: { + url: 'https://262.ecma-international.org/13.0/#eqn-TimeWithinDay' + }, + TimeZoneString: { + url: 'https://262.ecma-international.org/13.0/#sec-timezoneestring' + }, + ToBigInt: { + url: 'https://262.ecma-international.org/13.0/#sec-tobigint' + }, + ToBigInt64: { + url: 'https://262.ecma-international.org/13.0/#sec-tobigint64' + }, + ToBigUint64: { + url: 'https://262.ecma-international.org/13.0/#sec-tobiguint64' + }, + ToBoolean: { + url: 'https://262.ecma-international.org/13.0/#sec-toboolean' + }, + ToDateString: { + url: 'https://262.ecma-international.org/13.0/#sec-todatestring' + }, + ToIndex: { + url: 'https://262.ecma-international.org/13.0/#sec-toindex' + }, + ToInt16: { + url: 'https://262.ecma-international.org/13.0/#sec-toint16' + }, + ToInt32: { + url: 'https://262.ecma-international.org/13.0/#sec-toint32' + }, + ToInt8: { + url: 'https://262.ecma-international.org/13.0/#sec-toint8' + }, + ToIntegerOrInfinity: { + url: 'https://262.ecma-international.org/13.0/#sec-tointegerorinfinity' + }, + ToLength: { + url: 'https://262.ecma-international.org/13.0/#sec-tolength' + }, + ToNumber: { + url: 'https://262.ecma-international.org/13.0/#sec-tonumber' + }, + ToNumeric: { + url: 'https://262.ecma-international.org/13.0/#sec-tonumeric' + }, + ToObject: { + url: 'https://262.ecma-international.org/13.0/#sec-toobject' + }, + ToPrimitive: { + url: 'https://262.ecma-international.org/13.0/#sec-toprimitive' + }, + ToPropertyDescriptor: { + url: 'https://262.ecma-international.org/13.0/#sec-topropertydescriptor' + }, + ToPropertyKey: { + url: 'https://262.ecma-international.org/13.0/#sec-topropertykey' + }, + ToString: { + url: 'https://262.ecma-international.org/13.0/#sec-tostring' + }, + ToUint16: { + url: 'https://262.ecma-international.org/13.0/#sec-touint16' + }, + ToUint32: { + url: 'https://262.ecma-international.org/13.0/#sec-touint32' + }, + ToUint8: { + url: 'https://262.ecma-international.org/13.0/#sec-touint8' + }, + ToUint8Clamp: { + url: 'https://262.ecma-international.org/13.0/#sec-touint8clamp' + }, + ToZeroPaddedDecimalString: { + url: 'https://262.ecma-international.org/13.0/#sec-tozeropaddeddecimalstring' + }, + TriggerPromiseReactions: { + url: 'https://262.ecma-international.org/13.0/#sec-triggerpromisereactions' + }, + TrimString: { + url: 'https://262.ecma-international.org/13.0/#sec-trimstring' + }, + Type: { + url: 'https://262.ecma-international.org/13.0/#sec-ecmascript-data-types-and-values' + }, + TypedArrayCreate: { + url: 'https://262.ecma-international.org/13.0/#typedarray-create' + }, + TypedArrayElementSize: { + url: 'https://262.ecma-international.org/13.0/#sec-typedarrayelementsize' + }, + TypedArrayElementType: { + url: 'https://262.ecma-international.org/13.0/#sec-typedarrayelementtype' + }, + TypedArraySpeciesCreate: { + url: 'https://262.ecma-international.org/13.0/#typedarray-species-create' + }, + UnicodeEscape: { + url: 'https://262.ecma-international.org/13.0/#sec-unicodeescape' + }, + UnicodeMatchProperty: { + url: 'https://262.ecma-international.org/13.0/#sec-runtime-semantics-unicodematchproperty-p' + }, + UnicodeMatchPropertyValue: { + url: 'https://262.ecma-international.org/13.0/#sec-runtime-semantics-unicodematchpropertyvalue-p-v' + }, + UpdateEmpty: { + url: 'https://262.ecma-international.org/13.0/#sec-updateempty' + }, + UTC: { + url: 'https://262.ecma-international.org/13.0/#sec-utc-t' + }, + UTF16EncodeCodePoint: { + url: 'https://262.ecma-international.org/13.0/#sec-utf16encodecodepoint' + }, + UTF16SurrogatePairToCodePoint: { + url: 'https://262.ecma-international.org/13.0/#sec-utf16decodesurrogatepair' + }, + ValidateAndApplyPropertyDescriptor: { + url: 'https://262.ecma-international.org/13.0/#sec-validateandapplypropertydescriptor' + }, + ValidateAtomicAccess: { + url: 'https://262.ecma-international.org/13.0/#sec-validateatomicaccess' + }, + ValidateIntegerTypedArray: { + url: 'https://262.ecma-international.org/13.0/#sec-validateintegertypedarray' + }, + ValidateTypedArray: { + url: 'https://262.ecma-international.org/13.0/#sec-validatetypedarray' + }, + ValueOfReadEvent: { + url: 'https://262.ecma-international.org/13.0/#sec-valueofreadevent' + }, + WeakRefDeref: { + url: 'https://262.ecma-international.org/13.0/#sec-weakrefderef' + }, + WeekDay: { + url: 'https://262.ecma-international.org/13.0/#sec-week-day' + }, + WordCharacters: { + url: 'https://262.ecma-international.org/13.0/#sec-runtime-semantics-wordcharacters-abstract-operation' + }, + YearFromTime: { + url: 'https://262.ecma-international.org/13.0/#eqn-YearFromTime' + }, + Yield: { + url: 'https://262.ecma-international.org/13.0/#sec-yield' + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2023.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2023.js new file mode 100644 index 0000000000000000000000000000000000000000..9bd85dd79be49173d7ba9786fd18bdcd88bcbb3b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2023.js @@ -0,0 +1,1441 @@ +'use strict'; + +module.exports = { + abs: { + url: 'https://262.ecma-international.org/14.0/#eqn-abs' + }, + AddEntriesFromIterable: { + url: 'https://262.ecma-international.org/14.0/#sec-add-entries-from-iterable' + }, + AddRestrictedFunctionProperties: { + url: 'https://262.ecma-international.org/14.0/#sec-addrestrictedfunctionproperties' + }, + AddToKeptObjects: { + url: 'https://262.ecma-international.org/14.0/#sec-addtokeptobjects' + }, + AddWaiter: { + url: 'https://262.ecma-international.org/14.0/#sec-addwaiter' + }, + AdvanceStringIndex: { + url: 'https://262.ecma-international.org/14.0/#sec-advancestringindex' + }, + 'agent-order': { + url: 'https://262.ecma-international.org/14.0/#sec-agent-order' + }, + AgentCanSuspend: { + url: 'https://262.ecma-international.org/14.0/#sec-agentcansuspend' + }, + AgentSignifier: { + url: 'https://262.ecma-international.org/14.0/#sec-agentsignifier' + }, + AllocateArrayBuffer: { + url: 'https://262.ecma-international.org/14.0/#sec-allocatearraybuffer' + }, + AllocateSharedArrayBuffer: { + url: 'https://262.ecma-international.org/14.0/#sec-allocatesharedarraybuffer' + }, + AllocateTypedArray: { + url: 'https://262.ecma-international.org/14.0/#sec-allocatetypedarray' + }, + AllocateTypedArrayBuffer: { + url: 'https://262.ecma-international.org/14.0/#sec-allocatetypedarraybuffer' + }, + ApplyStringOrNumericBinaryOperator: { + url: 'https://262.ecma-international.org/14.0/#sec-applystringornumericbinaryoperator' + }, + ArrayCreate: { + url: 'https://262.ecma-international.org/14.0/#sec-arraycreate' + }, + ArraySetLength: { + url: 'https://262.ecma-international.org/14.0/#sec-arraysetlength' + }, + ArraySpeciesCreate: { + url: 'https://262.ecma-international.org/14.0/#sec-arrayspeciescreate' + }, + AsyncBlockStart: { + url: 'https://262.ecma-international.org/14.0/#sec-asyncblockstart' + }, + AsyncFromSyncIteratorContinuation: { + url: 'https://262.ecma-international.org/14.0/#sec-asyncfromsynciteratorcontinuation' + }, + AsyncFunctionStart: { + url: 'https://262.ecma-international.org/14.0/#sec-async-functions-abstract-operations-async-function-start' + }, + AsyncGeneratorAwaitReturn: { + url: 'https://262.ecma-international.org/14.0/#sec-asyncgeneratorawaitreturn' + }, + AsyncGeneratorCompleteStep: { + url: 'https://262.ecma-international.org/14.0/#sec-asyncgeneratorcompletestep' + }, + AsyncGeneratorDrainQueue: { + url: 'https://262.ecma-international.org/14.0/#sec-asyncgeneratordrainqueue' + }, + AsyncGeneratorEnqueue: { + url: 'https://262.ecma-international.org/14.0/#sec-asyncgeneratorenqueue' + }, + AsyncGeneratorResume: { + url: 'https://262.ecma-international.org/14.0/#sec-asyncgeneratorresume' + }, + AsyncGeneratorStart: { + url: 'https://262.ecma-international.org/14.0/#sec-asyncgeneratorstart' + }, + AsyncGeneratorUnwrapYieldResumption: { + url: 'https://262.ecma-international.org/14.0/#sec-asyncgeneratorunwrapyieldresumption' + }, + AsyncGeneratorValidate: { + url: 'https://262.ecma-international.org/14.0/#sec-asyncgeneratorvalidate' + }, + AsyncGeneratorYield: { + url: 'https://262.ecma-international.org/14.0/#sec-asyncgeneratoryield' + }, + AsyncIteratorClose: { + url: 'https://262.ecma-international.org/14.0/#sec-asynciteratorclose' + }, + AsyncModuleExecutionFulfilled: { + url: 'https://262.ecma-international.org/14.0/#sec-async-module-execution-fulfilled' + }, + AsyncModuleExecutionRejected: { + url: 'https://262.ecma-international.org/14.0/#sec-async-module-execution-rejected' + }, + AtomicReadModifyWrite: { + url: 'https://262.ecma-international.org/14.0/#sec-atomicreadmodifywrite' + }, + Await: { + url: 'https://262.ecma-international.org/14.0/#await' + }, + BackreferenceMatcher: { + url: 'https://262.ecma-international.org/14.0/#sec-backreference-matcher' + }, + 'BigInt::add': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-bigint-add' + }, + 'BigInt::bitwiseAND': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-bigint-bitwiseAND' + }, + 'BigInt::bitwiseNOT': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-bigint-bitwiseNOT' + }, + 'BigInt::bitwiseOR': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-bigint-bitwiseOR' + }, + 'BigInt::bitwiseXOR': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-bigint-bitwiseXOR' + }, + 'BigInt::divide': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-bigint-divide' + }, + 'BigInt::equal': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-bigint-equal' + }, + 'BigInt::exponentiate': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-bigint-exponentiate' + }, + 'BigInt::leftShift': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-bigint-leftShift' + }, + 'BigInt::lessThan': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-bigint-lessThan' + }, + 'BigInt::multiply': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-bigint-multiply' + }, + 'BigInt::remainder': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-bigint-remainder' + }, + 'BigInt::signedRightShift': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-bigint-signedRightShift' + }, + 'BigInt::subtract': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-bigint-subtract' + }, + 'BigInt::toString': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-bigint-tostring' + }, + 'BigInt::unaryMinus': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-bigint-unaryMinus' + }, + 'BigInt::unsignedRightShift': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-bigint-unsignedRightShift' + }, + BigIntBitwiseOp: { + url: 'https://262.ecma-international.org/14.0/#sec-bigintbitwiseop' + }, + BinaryAnd: { + url: 'https://262.ecma-international.org/14.0/#sec-binaryand' + }, + BinaryOr: { + url: 'https://262.ecma-international.org/14.0/#sec-binaryor' + }, + BinaryXor: { + url: 'https://262.ecma-international.org/14.0/#sec-binaryxor' + }, + BlockDeclarationInstantiation: { + url: 'https://262.ecma-international.org/14.0/#sec-blockdeclarationinstantiation' + }, + BoundFunctionCreate: { + url: 'https://262.ecma-international.org/14.0/#sec-boundfunctioncreate' + }, + ByteListBitwiseOp: { + url: 'https://262.ecma-international.org/14.0/#sec-bytelistbitwiseop' + }, + ByteListEqual: { + url: 'https://262.ecma-international.org/14.0/#sec-bytelistequal' + }, + Call: { + url: 'https://262.ecma-international.org/14.0/#sec-call' + }, + CanBeHeldWeakly: { + url: 'https://262.ecma-international.org/14.0/#sec-canbeheldweakly' + }, + Canonicalize: { + url: 'https://262.ecma-international.org/14.0/#sec-runtime-semantics-canonicalize-ch' + }, + CanonicalNumericIndexString: { + url: 'https://262.ecma-international.org/14.0/#sec-canonicalnumericindexstring' + }, + CaseClauseIsSelected: { + url: 'https://262.ecma-international.org/14.0/#sec-runtime-semantics-caseclauseisselected' + }, + CharacterRange: { + url: 'https://262.ecma-international.org/14.0/#sec-runtime-semantics-characterrange-abstract-operation' + }, + CharacterRangeOrUnion: { + url: 'https://262.ecma-international.org/14.0/#sec-runtime-semantics-characterrangeorunion-abstract-operation' + }, + CharacterSetMatcher: { + url: 'https://262.ecma-international.org/14.0/#sec-runtime-semantics-charactersetmatcher-abstract-operation' + }, + clamp: { + url: 'https://262.ecma-international.org/14.0/#clamping' + }, + CleanupFinalizationRegistry: { + url: 'https://262.ecma-international.org/14.0/#sec-cleanup-finalization-registry' + }, + ClearKeptObjects: { + url: 'https://262.ecma-international.org/14.0/#sec-clear-kept-objects' + }, + CloneArrayBuffer: { + url: 'https://262.ecma-international.org/14.0/#sec-clonearraybuffer' + }, + CodePointAt: { + url: 'https://262.ecma-international.org/14.0/#sec-codepointat' + }, + CodePointsToString: { + url: 'https://262.ecma-international.org/14.0/#sec-codepointstostring' + }, + CompareArrayElements: { + url: 'https://262.ecma-international.org/14.0/#sec-comparearrayelements' + }, + CompareTypedArrayElements: { + url: 'https://262.ecma-international.org/14.0/#sec-comparetypedarrayelements' + }, + CompletePropertyDescriptor: { + url: 'https://262.ecma-international.org/14.0/#sec-completepropertydescriptor' + }, + Completion: { + url: 'https://262.ecma-international.org/14.0/#sec-completion-ao' + }, + CompletionRecord: { + url: 'https://262.ecma-international.org/14.0/#sec-completion-record-specification-type' + }, + ComposeWriteEventBytes: { + url: 'https://262.ecma-international.org/14.0/#sec-composewriteeventbytes' + }, + Construct: { + url: 'https://262.ecma-international.org/14.0/#sec-construct' + }, + ContinueDynamicImport: { + url: 'https://262.ecma-international.org/14.0/#sec-ContinueDynamicImport' + }, + ContinueModuleLoading: { + url: 'https://262.ecma-international.org/14.0/#sec-ContinueModuleLoading' + }, + CopyDataBlockBytes: { + url: 'https://262.ecma-international.org/14.0/#sec-copydatablockbytes' + }, + CopyDataProperties: { + url: 'https://262.ecma-international.org/14.0/#sec-copydataproperties' + }, + CountLeftCapturingParensBefore: { + url: 'https://262.ecma-international.org/14.0/#sec-countleftcapturingparensbefore' + }, + CountLeftCapturingParensWithin: { + url: 'https://262.ecma-international.org/14.0/#sec-countleftcapturingparenswithin' + }, + CreateArrayFromList: { + url: 'https://262.ecma-international.org/14.0/#sec-createarrayfromlist' + }, + CreateArrayIterator: { + url: 'https://262.ecma-international.org/14.0/#sec-createarrayiterator' + }, + CreateAsyncFromSyncIterator: { + url: 'https://262.ecma-international.org/14.0/#sec-createasyncfromsynciterator' + }, + CreateAsyncIteratorFromClosure: { + url: 'https://262.ecma-international.org/14.0/#sec-createasynciteratorfromclosure' + }, + CreateBuiltinFunction: { + url: 'https://262.ecma-international.org/14.0/#sec-createbuiltinfunction' + }, + CreateByteDataBlock: { + url: 'https://262.ecma-international.org/14.0/#sec-createbytedatablock' + }, + CreateDataProperty: { + url: 'https://262.ecma-international.org/14.0/#sec-createdataproperty' + }, + CreateDataPropertyOrThrow: { + url: 'https://262.ecma-international.org/14.0/#sec-createdatapropertyorthrow' + }, + CreateDynamicFunction: { + url: 'https://262.ecma-international.org/14.0/#sec-createdynamicfunction' + }, + CreateForInIterator: { + url: 'https://262.ecma-international.org/14.0/#sec-createforiniterator' + }, + CreateHTML: { + url: 'https://262.ecma-international.org/14.0/#sec-createhtml' + }, + CreateIntrinsics: { + url: 'https://262.ecma-international.org/14.0/#sec-createintrinsics' + }, + CreateIteratorFromClosure: { + url: 'https://262.ecma-international.org/14.0/#sec-createiteratorfromclosure' + }, + CreateIterResultObject: { + url: 'https://262.ecma-international.org/14.0/#sec-createiterresultobject' + }, + CreateListFromArrayLike: { + url: 'https://262.ecma-international.org/14.0/#sec-createlistfromarraylike' + }, + CreateListIteratorRecord: { + url: 'https://262.ecma-international.org/14.0/#sec-createlistiteratorRecord' + }, + CreateMapIterator: { + url: 'https://262.ecma-international.org/14.0/#sec-createmapiterator' + }, + CreateMappedArgumentsObject: { + url: 'https://262.ecma-international.org/14.0/#sec-createmappedargumentsobject' + }, + CreateMethodProperty: { + url: 'https://262.ecma-international.org/14.0/#sec-createmethodproperty' + }, + CreateNonEnumerableDataPropertyOrThrow: { + url: 'https://262.ecma-international.org/14.0/#sec-createnonenumerabledatapropertyorthrow' + }, + CreatePerIterationEnvironment: { + url: 'https://262.ecma-international.org/14.0/#sec-createperiterationenvironment' + }, + CreateRealm: { + url: 'https://262.ecma-international.org/14.0/#sec-createrealm' + }, + CreateRegExpStringIterator: { + url: 'https://262.ecma-international.org/14.0/#sec-createregexpstringiterator' + }, + CreateResolvingFunctions: { + url: 'https://262.ecma-international.org/14.0/#sec-createresolvingfunctions' + }, + CreateSetIterator: { + url: 'https://262.ecma-international.org/14.0/#sec-createsetiterator' + }, + CreateSharedByteDataBlock: { + url: 'https://262.ecma-international.org/14.0/#sec-createsharedbytedatablock' + }, + CreateUnmappedArgumentsObject: { + url: 'https://262.ecma-international.org/14.0/#sec-createunmappedargumentsobject' + }, + DateFromTime: { + url: 'https://262.ecma-international.org/14.0/#sec-date-number' + }, + DateString: { + url: 'https://262.ecma-international.org/14.0/#sec-datestring' + }, + Day: { + url: 'https://262.ecma-international.org/14.0/#eqn-Day' + }, + DayFromYear: { + url: 'https://262.ecma-international.org/14.0/#eqn-DaysFromYear' + }, + DaysInYear: { + url: 'https://262.ecma-international.org/14.0/#eqn-DaysInYear' + }, + DayWithinYear: { + url: 'https://262.ecma-international.org/14.0/#eqn-DayWithinYear' + }, + Decode: { + url: 'https://262.ecma-international.org/14.0/#sec-decode' + }, + DefaultTimeZone: { + url: 'https://262.ecma-international.org/14.0/#sec-defaulttimezone' + }, + DefineField: { + url: 'https://262.ecma-international.org/14.0/#sec-definefield' + }, + DefineMethodProperty: { + url: 'https://262.ecma-international.org/14.0/#sec-definemethodproperty' + }, + DefinePropertyOrThrow: { + url: 'https://262.ecma-international.org/14.0/#sec-definepropertyorthrow' + }, + DeletePropertyOrThrow: { + url: 'https://262.ecma-international.org/14.0/#sec-deletepropertyorthrow' + }, + DetachArrayBuffer: { + url: 'https://262.ecma-international.org/14.0/#sec-detacharraybuffer' + }, + Encode: { + url: 'https://262.ecma-international.org/14.0/#sec-encode' + }, + EnterCriticalSection: { + url: 'https://262.ecma-international.org/14.0/#sec-entercriticalsection' + }, + EnumerableOwnProperties: { + url: 'https://262.ecma-international.org/14.0/#sec-enumerableownproperties' + }, + EnumerateObjectProperties: { + url: 'https://262.ecma-international.org/14.0/#sec-enumerate-object-properties' + }, + EscapeRegExpPattern: { + url: 'https://262.ecma-international.org/14.0/#sec-escaperegexppattern' + }, + EvalDeclarationInstantiation: { + url: 'https://262.ecma-international.org/14.0/#sec-evaldeclarationinstantiation' + }, + EvaluateCall: { + url: 'https://262.ecma-international.org/14.0/#sec-evaluatecall' + }, + EvaluateNew: { + url: 'https://262.ecma-international.org/14.0/#sec-evaluatenew' + }, + EvaluatePropertyAccessWithExpressionKey: { + url: 'https://262.ecma-international.org/14.0/#sec-evaluate-property-access-with-expression-key' + }, + EvaluatePropertyAccessWithIdentifierKey: { + url: 'https://262.ecma-international.org/14.0/#sec-evaluate-property-access-with-identifier-key' + }, + EvaluateStringOrNumericBinaryExpression: { + url: 'https://262.ecma-international.org/14.0/#sec-evaluatestringornumericbinaryexpression' + }, + EventSet: { + url: 'https://262.ecma-international.org/14.0/#sec-event-set' + }, + ExecuteAsyncModule: { + url: 'https://262.ecma-international.org/14.0/#sec-execute-async-module' + }, + '𝔽': { + url: 'https://262.ecma-international.org/14.0/#𝔽' + }, + FindViaPredicate: { + url: 'https://262.ecma-international.org/14.0/#sec-findviapredicate' + }, + FinishLoadingImportedModule: { + url: 'https://262.ecma-international.org/14.0/#sec-FinishLoadingImportedModule' + }, + FlattenIntoArray: { + url: 'https://262.ecma-international.org/14.0/#sec-flattenintoarray' + }, + floor: { + url: 'https://262.ecma-international.org/14.0/#eqn-floor' + }, + ForBodyEvaluation: { + url: 'https://262.ecma-international.org/14.0/#sec-forbodyevaluation' + }, + 'ForIn/OfBodyEvaluation': { + url: 'https://262.ecma-international.org/14.0/#sec-runtime-semantics-forin-div-ofbodyevaluation-lhs-stmt-iterator-lhskind-labelset' + }, + 'ForIn/OfHeadEvaluation': { + url: 'https://262.ecma-international.org/14.0/#sec-runtime-semantics-forinofheadevaluation' + }, + FromPropertyDescriptor: { + url: 'https://262.ecma-international.org/14.0/#sec-frompropertydescriptor' + }, + FulfillPromise: { + url: 'https://262.ecma-international.org/14.0/#sec-fulfillpromise' + }, + FunctionDeclarationInstantiation: { + url: 'https://262.ecma-international.org/14.0/#sec-functiondeclarationinstantiation' + }, + GatherAvailableAncestors: { + url: 'https://262.ecma-international.org/14.0/#sec-gather-available-ancestors' + }, + GeneratorResume: { + url: 'https://262.ecma-international.org/14.0/#sec-generatorresume' + }, + GeneratorResumeAbrupt: { + url: 'https://262.ecma-international.org/14.0/#sec-generatorresumeabrupt' + }, + GeneratorStart: { + url: 'https://262.ecma-international.org/14.0/#sec-generatorstart' + }, + GeneratorValidate: { + url: 'https://262.ecma-international.org/14.0/#sec-generatorvalidate' + }, + GeneratorYield: { + url: 'https://262.ecma-international.org/14.0/#sec-generatoryield' + }, + Get: { + url: 'https://262.ecma-international.org/14.0/#sec-get-o-p' + }, + GetActiveScriptOrModule: { + url: 'https://262.ecma-international.org/14.0/#sec-getactivescriptormodule' + }, + GetFunctionRealm: { + url: 'https://262.ecma-international.org/14.0/#sec-getfunctionrealm' + }, + GetGeneratorKind: { + url: 'https://262.ecma-international.org/14.0/#sec-getgeneratorkind' + }, + GetGlobalObject: { + url: 'https://262.ecma-international.org/14.0/#sec-getglobalobject' + }, + GetIdentifierReference: { + url: 'https://262.ecma-international.org/14.0/#sec-getidentifierreference' + }, + GetImportedModule: { + url: 'https://262.ecma-international.org/14.0/#sec-GetImportedModule' + }, + GetIterator: { + url: 'https://262.ecma-international.org/14.0/#sec-getiterator' + }, + GetIteratorFromMethod: { + url: 'https://262.ecma-international.org/14.0/#sec-getiteratorfrommethod' + }, + GetMatchIndexPair: { + url: 'https://262.ecma-international.org/14.0/#sec-getmatchindexpair' + }, + GetMatchString: { + url: 'https://262.ecma-international.org/14.0/#sec-getmatchstring' + }, + GetMethod: { + url: 'https://262.ecma-international.org/14.0/#sec-getmethod' + }, + GetModifySetValueInBuffer: { + url: 'https://262.ecma-international.org/14.0/#sec-getmodifysetvalueinbuffer' + }, + GetModuleNamespace: { + url: 'https://262.ecma-international.org/14.0/#sec-getmodulenamespace' + }, + GetNamedTimeZoneEpochNanoseconds: { + url: 'https://262.ecma-international.org/14.0/#sec-getnamedtimezoneepochnanoseconds' + }, + GetNamedTimeZoneOffsetNanoseconds: { + url: 'https://262.ecma-international.org/14.0/#sec-getnamedtimezoneoffsetnanoseconds' + }, + GetNewTarget: { + url: 'https://262.ecma-international.org/14.0/#sec-getnewtarget' + }, + GetOwnPropertyKeys: { + url: 'https://262.ecma-international.org/14.0/#sec-getownpropertykeys' + }, + GetPromiseResolve: { + url: 'https://262.ecma-international.org/14.0/#sec-getpromiseresolve' + }, + GetPrototypeFromConstructor: { + url: 'https://262.ecma-international.org/14.0/#sec-getprototypefromconstructor' + }, + GetStringIndex: { + url: 'https://262.ecma-international.org/14.0/#sec-getstringindex' + }, + GetSubstitution: { + url: 'https://262.ecma-international.org/14.0/#sec-getsubstitution' + }, + GetSuperConstructor: { + url: 'https://262.ecma-international.org/14.0/#sec-getsuperconstructor' + }, + GetTemplateObject: { + url: 'https://262.ecma-international.org/14.0/#sec-gettemplateobject' + }, + GetThisEnvironment: { + url: 'https://262.ecma-international.org/14.0/#sec-getthisenvironment' + }, + GetThisValue: { + url: 'https://262.ecma-international.org/14.0/#sec-getthisvalue' + }, + GetUTCEpochNanoseconds: { + url: 'https://262.ecma-international.org/14.0/#sec-getutcepochnanoseconds' + }, + GetV: { + url: 'https://262.ecma-international.org/14.0/#sec-getv' + }, + GetValue: { + url: 'https://262.ecma-international.org/14.0/#sec-getvalue' + }, + GetValueFromBuffer: { + url: 'https://262.ecma-international.org/14.0/#sec-getvaluefrombuffer' + }, + GetViewValue: { + url: 'https://262.ecma-international.org/14.0/#sec-getviewvalue' + }, + GetWaiterList: { + url: 'https://262.ecma-international.org/14.0/#sec-getwaiterlist' + }, + GlobalDeclarationInstantiation: { + url: 'https://262.ecma-international.org/14.0/#sec-globaldeclarationinstantiation' + }, + GroupSpecifiersThatMatch: { + url: 'https://262.ecma-international.org/14.0/#sec-groupspecifiersthatmatch' + }, + 'happens-before': { + url: 'https://262.ecma-international.org/14.0/#sec-happens-before' + }, + HasOwnProperty: { + url: 'https://262.ecma-international.org/14.0/#sec-hasownproperty' + }, + HasProperty: { + url: 'https://262.ecma-international.org/14.0/#sec-hasproperty' + }, + 'host-synchronizes-with': { + url: 'https://262.ecma-international.org/14.0/#sec-host-synchronizes-with' + }, + HostEventSet: { + url: 'https://262.ecma-international.org/14.0/#sec-hosteventset' + }, + HourFromTime: { + url: 'https://262.ecma-international.org/14.0/#eqn-HourFromTime' + }, + IfAbruptCloseIterator: { + url: 'https://262.ecma-international.org/14.0/#sec-ifabruptcloseiterator' + }, + IfAbruptRejectPromise: { + url: 'https://262.ecma-international.org/14.0/#sec-ifabruptrejectpromise' + }, + ImportedLocalNames: { + url: 'https://262.ecma-international.org/14.0/#sec-importedlocalnames' + }, + InitializeBoundName: { + url: 'https://262.ecma-international.org/14.0/#sec-initializeboundname' + }, + InitializeHostDefinedRealm: { + url: 'https://262.ecma-international.org/14.0/#sec-initializehostdefinedrealm' + }, + InitializeInstanceElements: { + url: 'https://262.ecma-international.org/14.0/#sec-initializeinstanceelements' + }, + InitializeReferencedBinding: { + url: 'https://262.ecma-international.org/14.0/#sec-initializereferencedbinding' + }, + InitializeTypedArrayFromArrayBuffer: { + url: 'https://262.ecma-international.org/14.0/#sec-initializetypedarrayfromarraybuffer' + }, + InitializeTypedArrayFromArrayLike: { + url: 'https://262.ecma-international.org/14.0/#sec-initializetypedarrayfromarraylike' + }, + InitializeTypedArrayFromList: { + url: 'https://262.ecma-international.org/14.0/#sec-initializetypedarrayfromlist' + }, + InitializeTypedArrayFromTypedArray: { + url: 'https://262.ecma-international.org/14.0/#sec-initializetypedarrayfromtypedarray' + }, + InLeapYear: { + url: 'https://262.ecma-international.org/14.0/#eqn-InLeapYear' + }, + InnerModuleEvaluation: { + url: 'https://262.ecma-international.org/14.0/#sec-innermoduleevaluation' + }, + InnerModuleLinking: { + url: 'https://262.ecma-international.org/14.0/#sec-InnerModuleLinking' + }, + InnerModuleLoading: { + url: 'https://262.ecma-international.org/14.0/#sec-InnerModuleLoading' + }, + InstallErrorCause: { + url: 'https://262.ecma-international.org/14.0/#sec-installerrorcause' + }, + InstanceofOperator: { + url: 'https://262.ecma-international.org/14.0/#sec-instanceofoperator' + }, + IntegerIndexedElementGet: { + url: 'https://262.ecma-international.org/14.0/#sec-integerindexedelementget' + }, + IntegerIndexedElementSet: { + url: 'https://262.ecma-international.org/14.0/#sec-integerindexedelementset' + }, + IntegerIndexedObjectCreate: { + url: 'https://262.ecma-international.org/14.0/#sec-integerindexedobjectcreate' + }, + InternalizeJSONProperty: { + url: 'https://262.ecma-international.org/14.0/#sec-internalizejsonproperty' + }, + Invoke: { + url: 'https://262.ecma-international.org/14.0/#sec-invoke' + }, + IsAccessorDescriptor: { + url: 'https://262.ecma-international.org/14.0/#sec-isaccessordescriptor' + }, + IsAnonymousFunctionDefinition: { + url: 'https://262.ecma-international.org/14.0/#sec-isanonymousfunctiondefinition' + }, + IsArray: { + url: 'https://262.ecma-international.org/14.0/#sec-isarray' + }, + IsBigIntElementType: { + url: 'https://262.ecma-international.org/14.0/#sec-isbigintelementtype' + }, + IsCallable: { + url: 'https://262.ecma-international.org/14.0/#sec-iscallable' + }, + IsCompatiblePropertyDescriptor: { + url: 'https://262.ecma-international.org/14.0/#sec-iscompatiblepropertydescriptor' + }, + IsConcatSpreadable: { + url: 'https://262.ecma-international.org/14.0/#sec-isconcatspreadable' + }, + IsConstructor: { + url: 'https://262.ecma-international.org/14.0/#sec-isconstructor' + }, + IsDataDescriptor: { + url: 'https://262.ecma-international.org/14.0/#sec-isdatadescriptor' + }, + IsDetachedBuffer: { + url: 'https://262.ecma-international.org/14.0/#sec-isdetachedbuffer' + }, + IsExtensible: { + url: 'https://262.ecma-international.org/14.0/#sec-isextensible-o' + }, + IsGenericDescriptor: { + url: 'https://262.ecma-international.org/14.0/#sec-isgenericdescriptor' + }, + IsInTailPosition: { + url: 'https://262.ecma-international.org/14.0/#sec-isintailposition' + }, + IsIntegralNumber: { + url: 'https://262.ecma-international.org/14.0/#sec-isintegralnumber' + }, + IsLabelledFunction: { + url: 'https://262.ecma-international.org/14.0/#sec-islabelledfunction' + }, + IsLessThan: { + url: 'https://262.ecma-international.org/14.0/#sec-islessthan' + }, + IsLooselyEqual: { + url: 'https://262.ecma-international.org/14.0/#sec-islooselyequal' + }, + IsNoTearConfiguration: { + url: 'https://262.ecma-international.org/14.0/#sec-isnotearconfiguration' + }, + IsPrivateReference: { + url: 'https://262.ecma-international.org/14.0/#sec-isprivatereference' + }, + IsPromise: { + url: 'https://262.ecma-international.org/14.0/#sec-ispromise' + }, + IsPropertyKey: { + url: 'https://262.ecma-international.org/14.0/#sec-ispropertykey' + }, + IsPropertyReference: { + url: 'https://262.ecma-international.org/14.0/#sec-ispropertyreference' + }, + IsRegExp: { + url: 'https://262.ecma-international.org/14.0/#sec-isregexp' + }, + IsSharedArrayBuffer: { + url: 'https://262.ecma-international.org/14.0/#sec-issharedarraybuffer' + }, + IsStrictlyEqual: { + url: 'https://262.ecma-international.org/14.0/#sec-isstrictlyequal' + }, + IsStringWellFormedUnicode: { + url: 'https://262.ecma-international.org/14.0/#sec-isstringwellformedunicode' + }, + IsSuperReference: { + url: 'https://262.ecma-international.org/14.0/#sec-issuperreference' + }, + IsTimeZoneOffsetString: { + url: 'https://262.ecma-international.org/14.0/#sec-istimezoneoffsetstring' + }, + IsUnclampedIntegerElementType: { + url: 'https://262.ecma-international.org/14.0/#sec-isunclampedintegerelementtype' + }, + IsUnresolvableReference: { + url: 'https://262.ecma-international.org/14.0/#sec-isunresolvablereference' + }, + IsUnsignedElementType: { + url: 'https://262.ecma-international.org/14.0/#sec-isunsignedelementtype' + }, + IsValidIntegerIndex: { + url: 'https://262.ecma-international.org/14.0/#sec-isvalidintegerindex' + }, + IsValidRegularExpressionLiteral: { + url: 'https://262.ecma-international.org/14.0/#sec-isvalidregularexpressionliteral' + }, + IsWordChar: { + url: 'https://262.ecma-international.org/14.0/#sec-runtime-semantics-iswordchar-abstract-operation' + }, + IteratorClose: { + url: 'https://262.ecma-international.org/14.0/#sec-iteratorclose' + }, + IteratorComplete: { + url: 'https://262.ecma-international.org/14.0/#sec-iteratorcomplete' + }, + IteratorNext: { + url: 'https://262.ecma-international.org/14.0/#sec-iteratornext' + }, + IteratorStep: { + url: 'https://262.ecma-international.org/14.0/#sec-iteratorstep' + }, + IteratorToList: { + url: 'https://262.ecma-international.org/14.0/#sec-iteratortolist' + }, + IteratorValue: { + url: 'https://262.ecma-international.org/14.0/#sec-iteratorvalue' + }, + KeyForSymbol: { + url: 'https://262.ecma-international.org/14.0/#sec-keyforsymbol' + }, + LeaveCriticalSection: { + url: 'https://262.ecma-international.org/14.0/#sec-leavecriticalsection' + }, + LengthOfArrayLike: { + url: 'https://262.ecma-international.org/14.0/#sec-lengthofarraylike' + }, + LocalTime: { + url: 'https://262.ecma-international.org/14.0/#sec-localtime' + }, + LoopContinues: { + url: 'https://262.ecma-international.org/14.0/#sec-loopcontinues' + }, + MakeArgGetter: { + url: 'https://262.ecma-international.org/14.0/#sec-makearggetter' + }, + MakeArgSetter: { + url: 'https://262.ecma-international.org/14.0/#sec-makeargsetter' + }, + MakeBasicObject: { + url: 'https://262.ecma-international.org/14.0/#sec-makebasicobject' + }, + MakeClassConstructor: { + url: 'https://262.ecma-international.org/14.0/#sec-makeclassconstructor' + }, + MakeConstructor: { + url: 'https://262.ecma-international.org/14.0/#sec-makeconstructor' + }, + MakeDate: { + url: 'https://262.ecma-international.org/14.0/#sec-makedate' + }, + MakeDay: { + url: 'https://262.ecma-international.org/14.0/#sec-makeday' + }, + MakeMatchIndicesIndexPairArray: { + url: 'https://262.ecma-international.org/14.0/#sec-makematchindicesindexpairarray' + }, + MakeMethod: { + url: 'https://262.ecma-international.org/14.0/#sec-makemethod' + }, + MakePrivateReference: { + url: 'https://262.ecma-international.org/14.0/#sec-makeprivatereference' + }, + MakeSuperPropertyReference: { + url: 'https://262.ecma-international.org/14.0/#sec-makesuperpropertyreference' + }, + MakeTime: { + url: 'https://262.ecma-international.org/14.0/#sec-maketime' + }, + max: { + url: 'https://262.ecma-international.org/14.0/#eqn-max' + }, + 'memory-order': { + url: 'https://262.ecma-international.org/14.0/#sec-memory-order' + }, + min: { + url: 'https://262.ecma-international.org/14.0/#eqn-min' + }, + MinFromTime: { + url: 'https://262.ecma-international.org/14.0/#eqn-MinFromTime' + }, + ModuleNamespaceCreate: { + url: 'https://262.ecma-international.org/14.0/#sec-modulenamespacecreate' + }, + modulo: { + url: 'https://262.ecma-international.org/14.0/#eqn-modulo' + }, + MonthFromTime: { + url: 'https://262.ecma-international.org/14.0/#eqn-MonthFromTime' + }, + msFromTime: { + url: 'https://262.ecma-international.org/14.0/#eqn-msFromTime' + }, + NewDeclarativeEnvironment: { + url: 'https://262.ecma-international.org/14.0/#sec-newdeclarativeenvironment' + }, + NewFunctionEnvironment: { + url: 'https://262.ecma-international.org/14.0/#sec-newfunctionenvironment' + }, + NewGlobalEnvironment: { + url: 'https://262.ecma-international.org/14.0/#sec-newglobalenvironment' + }, + NewModuleEnvironment: { + url: 'https://262.ecma-international.org/14.0/#sec-newmoduleenvironment' + }, + NewObjectEnvironment: { + url: 'https://262.ecma-international.org/14.0/#sec-newobjectenvironment' + }, + NewPrivateEnvironment: { + url: 'https://262.ecma-international.org/14.0/#sec-newprivateenvironment' + }, + NewPromiseCapability: { + url: 'https://262.ecma-international.org/14.0/#sec-newpromisecapability' + }, + NewPromiseReactionJob: { + url: 'https://262.ecma-international.org/14.0/#sec-newpromisereactionjob' + }, + NewPromiseResolveThenableJob: { + url: 'https://262.ecma-international.org/14.0/#sec-newpromiseresolvethenablejob' + }, + NormalCompletion: { + url: 'https://262.ecma-international.org/14.0/#sec-normalcompletion' + }, + NotifyWaiter: { + url: 'https://262.ecma-international.org/14.0/#sec-notifywaiter' + }, + 'Number::add': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-number-add' + }, + 'Number::bitwiseAND': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-number-bitwiseAND' + }, + 'Number::bitwiseNOT': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-number-bitwiseNOT' + }, + 'Number::bitwiseOR': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-number-bitwiseOR' + }, + 'Number::bitwiseXOR': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-number-bitwiseXOR' + }, + 'Number::divide': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-number-divide' + }, + 'Number::equal': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-number-equal' + }, + 'Number::exponentiate': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-number-exponentiate' + }, + 'Number::leftShift': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-number-leftShift' + }, + 'Number::lessThan': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-number-lessThan' + }, + 'Number::multiply': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-number-multiply' + }, + 'Number::remainder': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-number-remainder' + }, + 'Number::sameValue': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-number-sameValue' + }, + 'Number::sameValueZero': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-number-sameValueZero' + }, + 'Number::signedRightShift': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-number-signedRightShift' + }, + 'Number::subtract': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-number-subtract' + }, + 'Number::toString': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-number-tostring' + }, + 'Number::unaryMinus': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-number-unaryMinus' + }, + 'Number::unsignedRightShift': { + url: 'https://262.ecma-international.org/14.0/#sec-numeric-types-number-unsignedRightShift' + }, + NumberBitwiseOp: { + url: 'https://262.ecma-international.org/14.0/#sec-numberbitwiseop' + }, + NumberToBigInt: { + url: 'https://262.ecma-international.org/14.0/#sec-numbertobigint' + }, + NumericToRawBytes: { + url: 'https://262.ecma-international.org/14.0/#sec-numerictorawbytes' + }, + ObjectDefineProperties: { + url: 'https://262.ecma-international.org/14.0/#sec-objectdefineproperties' + }, + OrdinaryCallBindThis: { + url: 'https://262.ecma-international.org/14.0/#sec-ordinarycallbindthis' + }, + OrdinaryCallEvaluateBody: { + url: 'https://262.ecma-international.org/14.0/#sec-ordinarycallevaluatebody' + }, + OrdinaryCreateFromConstructor: { + url: 'https://262.ecma-international.org/14.0/#sec-ordinarycreatefromconstructor' + }, + OrdinaryDefineOwnProperty: { + url: 'https://262.ecma-international.org/14.0/#sec-ordinarydefineownproperty' + }, + OrdinaryDelete: { + url: 'https://262.ecma-international.org/14.0/#sec-ordinarydelete' + }, + OrdinaryFunctionCreate: { + url: 'https://262.ecma-international.org/14.0/#sec-ordinaryfunctioncreate' + }, + OrdinaryGet: { + url: 'https://262.ecma-international.org/14.0/#sec-ordinaryget' + }, + OrdinaryGetOwnProperty: { + url: 'https://262.ecma-international.org/14.0/#sec-ordinarygetownproperty' + }, + OrdinaryGetPrototypeOf: { + url: 'https://262.ecma-international.org/14.0/#sec-ordinarygetprototypeof' + }, + OrdinaryHasInstance: { + url: 'https://262.ecma-international.org/14.0/#sec-ordinaryhasinstance' + }, + OrdinaryHasProperty: { + url: 'https://262.ecma-international.org/14.0/#sec-ordinaryhasproperty' + }, + OrdinaryIsExtensible: { + url: 'https://262.ecma-international.org/14.0/#sec-ordinaryisextensible' + }, + OrdinaryObjectCreate: { + url: 'https://262.ecma-international.org/14.0/#sec-ordinaryobjectcreate' + }, + OrdinaryOwnPropertyKeys: { + url: 'https://262.ecma-international.org/14.0/#sec-ordinaryownpropertykeys' + }, + OrdinaryPreventExtensions: { + url: 'https://262.ecma-international.org/14.0/#sec-ordinarypreventextensions' + }, + OrdinarySet: { + url: 'https://262.ecma-international.org/14.0/#sec-ordinaryset' + }, + OrdinarySetPrototypeOf: { + url: 'https://262.ecma-international.org/14.0/#sec-ordinarysetprototypeof' + }, + OrdinarySetWithOwnDescriptor: { + url: 'https://262.ecma-international.org/14.0/#sec-ordinarysetwithowndescriptor' + }, + OrdinaryToPrimitive: { + url: 'https://262.ecma-international.org/14.0/#sec-ordinarytoprimitive' + }, + ParseHexOctet: { + url: 'https://262.ecma-international.org/14.0/#sec-parsehexoctet' + }, + ParseModule: { + url: 'https://262.ecma-international.org/14.0/#sec-parsemodule' + }, + ParsePattern: { + url: 'https://262.ecma-international.org/14.0/#sec-parsepattern' + }, + ParseScript: { + url: 'https://262.ecma-international.org/14.0/#sec-parse-script' + }, + ParseText: { + url: 'https://262.ecma-international.org/14.0/#sec-parsetext' + }, + ParseTimeZoneOffsetString: { + url: 'https://262.ecma-international.org/14.0/#sec-parsetimezoneoffsetstring' + }, + PerformEval: { + url: 'https://262.ecma-international.org/14.0/#sec-performeval' + }, + PerformPromiseAll: { + url: 'https://262.ecma-international.org/14.0/#sec-performpromiseall' + }, + PerformPromiseAllSettled: { + url: 'https://262.ecma-international.org/14.0/#sec-performpromiseallsettled' + }, + PerformPromiseAny: { + url: 'https://262.ecma-international.org/14.0/#sec-performpromiseany' + }, + PerformPromiseRace: { + url: 'https://262.ecma-international.org/14.0/#sec-performpromiserace' + }, + PerformPromiseThen: { + url: 'https://262.ecma-international.org/14.0/#sec-performpromisethen' + }, + PrepareForOrdinaryCall: { + url: 'https://262.ecma-international.org/14.0/#sec-prepareforordinarycall' + }, + PrepareForTailCall: { + url: 'https://262.ecma-international.org/14.0/#sec-preparefortailcall' + }, + PrivateElementFind: { + url: 'https://262.ecma-international.org/14.0/#sec-privateelementfind' + }, + PrivateFieldAdd: { + url: 'https://262.ecma-international.org/14.0/#sec-privatefieldadd' + }, + PrivateGet: { + url: 'https://262.ecma-international.org/14.0/#sec-privateget' + }, + PrivateMethodOrAccessorAdd: { + url: 'https://262.ecma-international.org/14.0/#sec-privatemethodoraccessoradd' + }, + PrivateSet: { + url: 'https://262.ecma-international.org/14.0/#sec-privateset' + }, + PromiseResolve: { + url: 'https://262.ecma-international.org/14.0/#sec-promise-resolve' + }, + ProxyCreate: { + url: 'https://262.ecma-international.org/14.0/#sec-proxycreate' + }, + PutValue: { + url: 'https://262.ecma-international.org/14.0/#sec-putvalue' + }, + QuoteJSONString: { + url: 'https://262.ecma-international.org/14.0/#sec-quotejsonstring' + }, + ℝ: { + url: 'https://262.ecma-international.org/14.0/#ℝ' + }, + RawBytesToNumeric: { + url: 'https://262.ecma-international.org/14.0/#sec-rawbytestonumeric' + }, + 'reads-bytes-from': { + url: 'https://262.ecma-international.org/14.0/#sec-reads-bytes-from' + }, + 'reads-from': { + url: 'https://262.ecma-international.org/14.0/#sec-reads-from' + }, + RegExpAlloc: { + url: 'https://262.ecma-international.org/14.0/#sec-regexpalloc' + }, + RegExpBuiltinExec: { + url: 'https://262.ecma-international.org/14.0/#sec-regexpbuiltinexec' + }, + RegExpCreate: { + url: 'https://262.ecma-international.org/14.0/#sec-regexpcreate' + }, + RegExpExec: { + url: 'https://262.ecma-international.org/14.0/#sec-regexpexec' + }, + RegExpHasFlag: { + url: 'https://262.ecma-international.org/14.0/#sec-regexphasflag' + }, + RegExpInitialize: { + url: 'https://262.ecma-international.org/14.0/#sec-regexpinitialize' + }, + RejectPromise: { + url: 'https://262.ecma-international.org/14.0/#sec-rejectpromise' + }, + RemoveWaiter: { + url: 'https://262.ecma-international.org/14.0/#sec-removewaiter' + }, + RemoveWaiters: { + url: 'https://262.ecma-international.org/14.0/#sec-removewaiters' + }, + RepeatMatcher: { + url: 'https://262.ecma-international.org/14.0/#sec-runtime-semantics-repeatmatcher-abstract-operation' + }, + RequireInternalSlot: { + url: 'https://262.ecma-international.org/14.0/#sec-requireinternalslot' + }, + RequireObjectCoercible: { + url: 'https://262.ecma-international.org/14.0/#sec-requireobjectcoercible' + }, + ResolveBinding: { + url: 'https://262.ecma-international.org/14.0/#sec-resolvebinding' + }, + ResolvePrivateIdentifier: { + url: 'https://262.ecma-international.org/14.0/#sec-resolve-private-identifier' + }, + ResolveThisBinding: { + url: 'https://262.ecma-international.org/14.0/#sec-resolvethisbinding' + }, + ReturnIfAbrupt: { + url: 'https://262.ecma-international.org/14.0/#sec-returnifabrupt' + }, + RoundMVResult: { + url: 'https://262.ecma-international.org/14.0/#sec-roundmvresult' + }, + SameValue: { + url: 'https://262.ecma-international.org/14.0/#sec-samevalue' + }, + SameValueNonNumber: { + url: 'https://262.ecma-international.org/14.0/#sec-samevaluenonnumber' + }, + SameValueZero: { + url: 'https://262.ecma-international.org/14.0/#sec-samevaluezero' + }, + ScriptEvaluation: { + url: 'https://262.ecma-international.org/14.0/#sec-runtime-semantics-scriptevaluation' + }, + SecFromTime: { + url: 'https://262.ecma-international.org/14.0/#eqn-SecFromTime' + }, + SerializeJSONArray: { + url: 'https://262.ecma-international.org/14.0/#sec-serializejsonarray' + }, + SerializeJSONObject: { + url: 'https://262.ecma-international.org/14.0/#sec-serializejsonobject' + }, + SerializeJSONProperty: { + url: 'https://262.ecma-international.org/14.0/#sec-serializejsonproperty' + }, + Set: { + url: 'https://262.ecma-international.org/14.0/#sec-set-o-p-v-throw' + }, + SetDefaultGlobalBindings: { + url: 'https://262.ecma-international.org/14.0/#sec-setdefaultglobalbindings' + }, + SetFunctionLength: { + url: 'https://262.ecma-international.org/14.0/#sec-setfunctionlength' + }, + SetFunctionName: { + url: 'https://262.ecma-international.org/14.0/#sec-setfunctionname' + }, + SetImmutablePrototype: { + url: 'https://262.ecma-international.org/14.0/#sec-set-immutable-prototype' + }, + SetIntegrityLevel: { + url: 'https://262.ecma-international.org/14.0/#sec-setintegritylevel' + }, + SetRealmGlobalObject: { + url: 'https://262.ecma-international.org/14.0/#sec-setrealmglobalobject' + }, + SetTypedArrayFromArrayLike: { + url: 'https://262.ecma-international.org/14.0/#sec-settypedarrayfromarraylike' + }, + SetTypedArrayFromTypedArray: { + url: 'https://262.ecma-international.org/14.0/#sec-settypedarrayfromtypedarray' + }, + SetValueInBuffer: { + url: 'https://262.ecma-international.org/14.0/#sec-setvalueinbuffer' + }, + SetViewValue: { + url: 'https://262.ecma-international.org/14.0/#sec-setviewvalue' + }, + SharedDataBlockEventSet: { + url: 'https://262.ecma-international.org/14.0/#sec-sharedatablockeventset' + }, + SortIndexedProperties: { + url: 'https://262.ecma-international.org/14.0/#sec-sortindexedproperties' + }, + SpeciesConstructor: { + url: 'https://262.ecma-international.org/14.0/#sec-speciesconstructor' + }, + StringCreate: { + url: 'https://262.ecma-international.org/14.0/#sec-stringcreate' + }, + StringGetOwnProperty: { + url: 'https://262.ecma-international.org/14.0/#sec-stringgetownproperty' + }, + StringIndexOf: { + url: 'https://262.ecma-international.org/14.0/#sec-stringindexof' + }, + StringPad: { + url: 'https://262.ecma-international.org/14.0/#sec-stringpad' + }, + StringToBigInt: { + url: 'https://262.ecma-international.org/14.0/#sec-stringtobigint' + }, + StringToCodePoints: { + url: 'https://262.ecma-international.org/14.0/#sec-stringtocodepoints' + }, + StringToNumber: { + url: 'https://262.ecma-international.org/14.0/#sec-stringtonumber' + }, + substring: { + url: 'https://262.ecma-international.org/14.0/#substring' + }, + SuspendAgent: { + url: 'https://262.ecma-international.org/14.0/#sec-suspendagent' + }, + SymbolDescriptiveString: { + url: 'https://262.ecma-international.org/14.0/#sec-symboldescriptivestring' + }, + 'synchronizes-with': { + url: 'https://262.ecma-international.org/14.0/#sec-synchronizes-with' + }, + TemplateString: { + url: 'https://262.ecma-international.org/14.0/#sec-templatestring' + }, + TestIntegrityLevel: { + url: 'https://262.ecma-international.org/14.0/#sec-testintegritylevel' + }, + thisBigIntValue: { + url: 'https://262.ecma-international.org/14.0/#thisbigintvalue' + }, + thisBooleanValue: { + url: 'https://262.ecma-international.org/14.0/#thisbooleanvalue' + }, + thisNumberValue: { + url: 'https://262.ecma-international.org/14.0/#thisnumbervalue' + }, + thisStringValue: { + url: 'https://262.ecma-international.org/14.0/#thisstringvalue' + }, + thisSymbolValue: { + url: 'https://262.ecma-international.org/14.0/#thissymbolvalue' + }, + thisTimeValue: { + url: 'https://262.ecma-international.org/14.0/#thistimevalue' + }, + ThrowCompletion: { + url: 'https://262.ecma-international.org/14.0/#sec-throwcompletion' + }, + TimeClip: { + url: 'https://262.ecma-international.org/14.0/#sec-timeclip' + }, + TimeFromYear: { + url: 'https://262.ecma-international.org/14.0/#eqn-TimeFromYear' + }, + TimeString: { + url: 'https://262.ecma-international.org/14.0/#sec-timestring' + }, + TimeWithinDay: { + url: 'https://262.ecma-international.org/14.0/#eqn-TimeWithinDay' + }, + TimeZoneString: { + url: 'https://262.ecma-international.org/14.0/#sec-timezoneestring' + }, + ToBigInt: { + url: 'https://262.ecma-international.org/14.0/#sec-tobigint' + }, + ToBigInt64: { + url: 'https://262.ecma-international.org/14.0/#sec-tobigint64' + }, + ToBigUint64: { + url: 'https://262.ecma-international.org/14.0/#sec-tobiguint64' + }, + ToBoolean: { + url: 'https://262.ecma-international.org/14.0/#sec-toboolean' + }, + ToDateString: { + url: 'https://262.ecma-international.org/14.0/#sec-todatestring' + }, + ToIndex: { + url: 'https://262.ecma-international.org/14.0/#sec-toindex' + }, + ToInt16: { + url: 'https://262.ecma-international.org/14.0/#sec-toint16' + }, + ToInt32: { + url: 'https://262.ecma-international.org/14.0/#sec-toint32' + }, + ToInt8: { + url: 'https://262.ecma-international.org/14.0/#sec-toint8' + }, + ToIntegerOrInfinity: { + url: 'https://262.ecma-international.org/14.0/#sec-tointegerorinfinity' + }, + ToLength: { + url: 'https://262.ecma-international.org/14.0/#sec-tolength' + }, + ToNumber: { + url: 'https://262.ecma-international.org/14.0/#sec-tonumber' + }, + ToNumeric: { + url: 'https://262.ecma-international.org/14.0/#sec-tonumeric' + }, + ToObject: { + url: 'https://262.ecma-international.org/14.0/#sec-toobject' + }, + ToPrimitive: { + url: 'https://262.ecma-international.org/14.0/#sec-toprimitive' + }, + ToPropertyDescriptor: { + url: 'https://262.ecma-international.org/14.0/#sec-topropertydescriptor' + }, + ToPropertyKey: { + url: 'https://262.ecma-international.org/14.0/#sec-topropertykey' + }, + ToString: { + url: 'https://262.ecma-international.org/14.0/#sec-tostring' + }, + ToUint16: { + url: 'https://262.ecma-international.org/14.0/#sec-touint16' + }, + ToUint32: { + url: 'https://262.ecma-international.org/14.0/#sec-touint32' + }, + ToUint8: { + url: 'https://262.ecma-international.org/14.0/#sec-touint8' + }, + ToUint8Clamp: { + url: 'https://262.ecma-international.org/14.0/#sec-touint8clamp' + }, + ToZeroPaddedDecimalString: { + url: 'https://262.ecma-international.org/14.0/#sec-tozeropaddeddecimalstring' + }, + TriggerPromiseReactions: { + url: 'https://262.ecma-international.org/14.0/#sec-triggerpromisereactions' + }, + TrimString: { + url: 'https://262.ecma-international.org/14.0/#sec-trimstring' + }, + truncate: { + url: 'https://262.ecma-international.org/14.0/#eqn-truncate' + }, + Type: { + url: 'https://262.ecma-international.org/14.0/#sec-ecmascript-data-types-and-values' + }, + TypedArrayCreate: { + url: 'https://262.ecma-international.org/14.0/#typedarray-create' + }, + TypedArrayCreateSameType: { + url: 'https://262.ecma-international.org/14.0/#sec-typedarray-create-same-type' + }, + TypedArrayElementSize: { + url: 'https://262.ecma-international.org/14.0/#sec-typedarrayelementsize' + }, + TypedArrayElementType: { + url: 'https://262.ecma-international.org/14.0/#sec-typedarrayelementtype' + }, + TypedArraySpeciesCreate: { + url: 'https://262.ecma-international.org/14.0/#typedarray-species-create' + }, + UnicodeEscape: { + url: 'https://262.ecma-international.org/14.0/#sec-unicodeescape' + }, + UnicodeMatchProperty: { + url: 'https://262.ecma-international.org/14.0/#sec-runtime-semantics-unicodematchproperty-p' + }, + UnicodeMatchPropertyValue: { + url: 'https://262.ecma-international.org/14.0/#sec-runtime-semantics-unicodematchpropertyvalue-p-v' + }, + UpdateEmpty: { + url: 'https://262.ecma-international.org/14.0/#sec-updateempty' + }, + UTC: { + url: 'https://262.ecma-international.org/14.0/#sec-utc-t' + }, + UTF16EncodeCodePoint: { + url: 'https://262.ecma-international.org/14.0/#sec-utf16encodecodepoint' + }, + UTF16SurrogatePairToCodePoint: { + url: 'https://262.ecma-international.org/14.0/#sec-utf16decodesurrogatepair' + }, + ValidateAndApplyPropertyDescriptor: { + url: 'https://262.ecma-international.org/14.0/#sec-validateandapplypropertydescriptor' + }, + ValidateAtomicAccess: { + url: 'https://262.ecma-international.org/14.0/#sec-validateatomicaccess' + }, + ValidateIntegerTypedArray: { + url: 'https://262.ecma-international.org/14.0/#sec-validateintegertypedarray' + }, + ValidateNonRevokedProxy: { + url: 'https://262.ecma-international.org/14.0/#sec-validatenonrevokedproxy' + }, + ValidateTypedArray: { + url: 'https://262.ecma-international.org/14.0/#sec-validatetypedarray' + }, + ValueOfReadEvent: { + url: 'https://262.ecma-international.org/14.0/#sec-valueofreadevent' + }, + WeakRefDeref: { + url: 'https://262.ecma-international.org/14.0/#sec-weakrefderef' + }, + WeekDay: { + url: 'https://262.ecma-international.org/14.0/#sec-week-day' + }, + WordCharacters: { + url: 'https://262.ecma-international.org/14.0/#sec-wordcharacters' + }, + YearFromTime: { + url: 'https://262.ecma-international.org/14.0/#eqn-YearFromTime' + }, + Yield: { + url: 'https://262.ecma-international.org/14.0/#sec-yield' + }, + ℤ: { + url: 'https://262.ecma-international.org/14.0/#ℤ' + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2024.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2024.js new file mode 100644 index 0000000000000000000000000000000000000000..ea5f5c1b262ae57462ba5070e7968e1fbe39e422 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2024.js @@ -0,0 +1,1537 @@ +'use strict'; + +module.exports = { + abs: { + url: 'https://262.ecma-international.org/15.0/#eqn-abs' + }, + AddEntriesFromIterable: { + url: 'https://262.ecma-international.org/15.0/#sec-add-entries-from-iterable' + }, + AddRestrictedFunctionProperties: { + url: 'https://262.ecma-international.org/15.0/#sec-addrestrictedfunctionproperties' + }, + AddToKeptObjects: { + url: 'https://262.ecma-international.org/15.0/#sec-addtokeptobjects' + }, + AddValueToKeyedGroup: { + url: 'https://262.ecma-international.org/15.0/#sec-add-value-to-keyed-group' + }, + AddWaiter: { + url: 'https://262.ecma-international.org/15.0/#sec-addwaiter' + }, + AdvanceStringIndex: { + url: 'https://262.ecma-international.org/15.0/#sec-advancestringindex' + }, + 'agent-order': { + url: 'https://262.ecma-international.org/15.0/#sec-agent-order' + }, + AgentCanSuspend: { + url: 'https://262.ecma-international.org/15.0/#sec-agentcansuspend' + }, + AgentSignifier: { + url: 'https://262.ecma-international.org/15.0/#sec-agentsignifier' + }, + AllCharacters: { + url: 'https://262.ecma-international.org/15.0/#sec-allcharacters' + }, + AllocateArrayBuffer: { + url: 'https://262.ecma-international.org/15.0/#sec-allocatearraybuffer' + }, + AllocateSharedArrayBuffer: { + url: 'https://262.ecma-international.org/15.0/#sec-allocatesharedarraybuffer' + }, + AllocateTypedArray: { + url: 'https://262.ecma-international.org/15.0/#sec-allocatetypedarray' + }, + AllocateTypedArrayBuffer: { + url: 'https://262.ecma-international.org/15.0/#sec-allocatetypedarraybuffer' + }, + ApplyStringOrNumericBinaryOperator: { + url: 'https://262.ecma-international.org/15.0/#sec-applystringornumericbinaryoperator' + }, + ArrayBufferByteLength: { + url: 'https://262.ecma-international.org/15.0/#sec-arraybufferbytelength' + }, + ArrayBufferCopyAndDetach: { + url: 'https://262.ecma-international.org/15.0/#sec-arraybuffercopyanddetach' + }, + ArrayCreate: { + url: 'https://262.ecma-international.org/15.0/#sec-arraycreate' + }, + ArraySetLength: { + url: 'https://262.ecma-international.org/15.0/#sec-arraysetlength' + }, + ArraySpeciesCreate: { + url: 'https://262.ecma-international.org/15.0/#sec-arrayspeciescreate' + }, + AsyncBlockStart: { + url: 'https://262.ecma-international.org/15.0/#sec-asyncblockstart' + }, + AsyncFromSyncIteratorContinuation: { + url: 'https://262.ecma-international.org/15.0/#sec-asyncfromsynciteratorcontinuation' + }, + AsyncFunctionStart: { + url: 'https://262.ecma-international.org/15.0/#sec-async-functions-abstract-operations-async-function-start' + }, + AsyncGeneratorAwaitReturn: { + url: 'https://262.ecma-international.org/15.0/#sec-asyncgeneratorawaitreturn' + }, + AsyncGeneratorCompleteStep: { + url: 'https://262.ecma-international.org/15.0/#sec-asyncgeneratorcompletestep' + }, + AsyncGeneratorDrainQueue: { + url: 'https://262.ecma-international.org/15.0/#sec-asyncgeneratordrainqueue' + }, + AsyncGeneratorEnqueue: { + url: 'https://262.ecma-international.org/15.0/#sec-asyncgeneratorenqueue' + }, + AsyncGeneratorResume: { + url: 'https://262.ecma-international.org/15.0/#sec-asyncgeneratorresume' + }, + AsyncGeneratorStart: { + url: 'https://262.ecma-international.org/15.0/#sec-asyncgeneratorstart' + }, + AsyncGeneratorUnwrapYieldResumption: { + url: 'https://262.ecma-international.org/15.0/#sec-asyncgeneratorunwrapyieldresumption' + }, + AsyncGeneratorValidate: { + url: 'https://262.ecma-international.org/15.0/#sec-asyncgeneratorvalidate' + }, + AsyncGeneratorYield: { + url: 'https://262.ecma-international.org/15.0/#sec-asyncgeneratoryield' + }, + AsyncIteratorClose: { + url: 'https://262.ecma-international.org/15.0/#sec-asynciteratorclose' + }, + AsyncModuleExecutionFulfilled: { + url: 'https://262.ecma-international.org/15.0/#sec-async-module-execution-fulfilled' + }, + AsyncModuleExecutionRejected: { + url: 'https://262.ecma-international.org/15.0/#sec-async-module-execution-rejected' + }, + AtomicCompareExchangeInSharedBlock: { + url: 'https://262.ecma-international.org/15.0/#sec-atomiccompareexchangeinsharedblock' + }, + AtomicReadModifyWrite: { + url: 'https://262.ecma-international.org/15.0/#sec-atomicreadmodifywrite' + }, + AvailableNamedTimeZoneIdentifiers: { + url: 'https://262.ecma-international.org/15.0/#sec-availablenamedtimezoneidentifiers' + }, + Await: { + url: 'https://262.ecma-international.org/15.0/#await' + }, + BackreferenceMatcher: { + url: 'https://262.ecma-international.org/15.0/#sec-backreference-matcher' + }, + 'BigInt::add': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-bigint-add' + }, + 'BigInt::bitwiseAND': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-bigint-bitwiseAND' + }, + 'BigInt::bitwiseNOT': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-bigint-bitwiseNOT' + }, + 'BigInt::bitwiseOR': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-bigint-bitwiseOR' + }, + 'BigInt::bitwiseXOR': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-bigint-bitwiseXOR' + }, + 'BigInt::divide': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-bigint-divide' + }, + 'BigInt::equal': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-bigint-equal' + }, + 'BigInt::exponentiate': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-bigint-exponentiate' + }, + 'BigInt::leftShift': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-bigint-leftShift' + }, + 'BigInt::lessThan': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-bigint-lessThan' + }, + 'BigInt::multiply': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-bigint-multiply' + }, + 'BigInt::remainder': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-bigint-remainder' + }, + 'BigInt::signedRightShift': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-bigint-signedRightShift' + }, + 'BigInt::subtract': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-bigint-subtract' + }, + 'BigInt::toString': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-bigint-tostring' + }, + 'BigInt::unaryMinus': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-bigint-unaryMinus' + }, + 'BigInt::unsignedRightShift': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-bigint-unsignedRightShift' + }, + BigIntBitwiseOp: { + url: 'https://262.ecma-international.org/15.0/#sec-bigintbitwiseop' + }, + BinaryAnd: { + url: 'https://262.ecma-international.org/15.0/#sec-binaryand' + }, + BinaryOr: { + url: 'https://262.ecma-international.org/15.0/#sec-binaryor' + }, + BinaryXor: { + url: 'https://262.ecma-international.org/15.0/#sec-binaryxor' + }, + BlockDeclarationInstantiation: { + url: 'https://262.ecma-international.org/15.0/#sec-blockdeclarationinstantiation' + }, + BoundFunctionCreate: { + url: 'https://262.ecma-international.org/15.0/#sec-boundfunctioncreate' + }, + BuiltinCallOrConstruct: { + url: 'https://262.ecma-international.org/15.0/#sec-builtincallorconstruct' + }, + ByteListBitwiseOp: { + url: 'https://262.ecma-international.org/15.0/#sec-bytelistbitwiseop' + }, + ByteListEqual: { + url: 'https://262.ecma-international.org/15.0/#sec-bytelistequal' + }, + Call: { + url: 'https://262.ecma-international.org/15.0/#sec-call' + }, + CanBeHeldWeakly: { + url: 'https://262.ecma-international.org/15.0/#sec-canbeheldweakly' + }, + Canonicalize: { + url: 'https://262.ecma-international.org/15.0/#sec-runtime-semantics-canonicalize-ch' + }, + CanonicalNumericIndexString: { + url: 'https://262.ecma-international.org/15.0/#sec-canonicalnumericindexstring' + }, + CaseClauseIsSelected: { + url: 'https://262.ecma-international.org/15.0/#sec-runtime-semantics-caseclauseisselected' + }, + CharacterComplement: { + url: 'https://262.ecma-international.org/15.0/#sec-charactercomplement' + }, + CharacterRange: { + url: 'https://262.ecma-international.org/15.0/#sec-runtime-semantics-characterrange-abstract-operation' + }, + CharacterRangeOrUnion: { + url: 'https://262.ecma-international.org/15.0/#sec-runtime-semantics-characterrangeorunion-abstract-operation' + }, + CharacterSetMatcher: { + url: 'https://262.ecma-international.org/15.0/#sec-runtime-semantics-charactersetmatcher-abstract-operation' + }, + clamp: { + url: 'https://262.ecma-international.org/15.0/#clamping' + }, + CleanupFinalizationRegistry: { + url: 'https://262.ecma-international.org/15.0/#sec-cleanup-finalization-registry' + }, + ClearKeptObjects: { + url: 'https://262.ecma-international.org/15.0/#sec-clear-kept-objects' + }, + CloneArrayBuffer: { + url: 'https://262.ecma-international.org/15.0/#sec-clonearraybuffer' + }, + CodePointAt: { + url: 'https://262.ecma-international.org/15.0/#sec-codepointat' + }, + CodePointsToString: { + url: 'https://262.ecma-international.org/15.0/#sec-codepointstostring' + }, + CompareArrayElements: { + url: 'https://262.ecma-international.org/15.0/#sec-comparearrayelements' + }, + CompareTypedArrayElements: { + url: 'https://262.ecma-international.org/15.0/#sec-comparetypedarrayelements' + }, + CompletePropertyDescriptor: { + url: 'https://262.ecma-international.org/15.0/#sec-completepropertydescriptor' + }, + Completion: { + url: 'https://262.ecma-international.org/15.0/#sec-completion-ao' + }, + CompletionRecord: { + url: 'https://262.ecma-international.org/15.0/#sec-completion-record-specification-type' + }, + ComposeWriteEventBytes: { + url: 'https://262.ecma-international.org/15.0/#sec-composewriteeventbytes' + }, + Construct: { + url: 'https://262.ecma-international.org/15.0/#sec-construct' + }, + ContinueDynamicImport: { + url: 'https://262.ecma-international.org/15.0/#sec-ContinueDynamicImport' + }, + ContinueModuleLoading: { + url: 'https://262.ecma-international.org/15.0/#sec-ContinueModuleLoading' + }, + CopyDataBlockBytes: { + url: 'https://262.ecma-international.org/15.0/#sec-copydatablockbytes' + }, + CopyDataProperties: { + url: 'https://262.ecma-international.org/15.0/#sec-copydataproperties' + }, + CountLeftCapturingParensBefore: { + url: 'https://262.ecma-international.org/15.0/#sec-countleftcapturingparensbefore' + }, + CountLeftCapturingParensWithin: { + url: 'https://262.ecma-international.org/15.0/#sec-countleftcapturingparenswithin' + }, + CreateArrayFromList: { + url: 'https://262.ecma-international.org/15.0/#sec-createarrayfromlist' + }, + CreateArrayIterator: { + url: 'https://262.ecma-international.org/15.0/#sec-createarrayiterator' + }, + CreateAsyncFromSyncIterator: { + url: 'https://262.ecma-international.org/15.0/#sec-createasyncfromsynciterator' + }, + CreateAsyncIteratorFromClosure: { + url: 'https://262.ecma-international.org/15.0/#sec-createasynciteratorfromclosure' + }, + CreateBuiltinFunction: { + url: 'https://262.ecma-international.org/15.0/#sec-createbuiltinfunction' + }, + CreateByteDataBlock: { + url: 'https://262.ecma-international.org/15.0/#sec-createbytedatablock' + }, + CreateDataProperty: { + url: 'https://262.ecma-international.org/15.0/#sec-createdataproperty' + }, + CreateDataPropertyOrThrow: { + url: 'https://262.ecma-international.org/15.0/#sec-createdatapropertyorthrow' + }, + CreateDynamicFunction: { + url: 'https://262.ecma-international.org/15.0/#sec-createdynamicfunction' + }, + CreateForInIterator: { + url: 'https://262.ecma-international.org/15.0/#sec-createforiniterator' + }, + CreateHTML: { + url: 'https://262.ecma-international.org/15.0/#sec-createhtml' + }, + CreateIntrinsics: { + url: 'https://262.ecma-international.org/15.0/#sec-createintrinsics' + }, + CreateIteratorFromClosure: { + url: 'https://262.ecma-international.org/15.0/#sec-createiteratorfromclosure' + }, + CreateIterResultObject: { + url: 'https://262.ecma-international.org/15.0/#sec-createiterresultobject' + }, + CreateListFromArrayLike: { + url: 'https://262.ecma-international.org/15.0/#sec-createlistfromarraylike' + }, + CreateListIteratorRecord: { + url: 'https://262.ecma-international.org/15.0/#sec-createlistiteratorRecord' + }, + CreateMapIterator: { + url: 'https://262.ecma-international.org/15.0/#sec-createmapiterator' + }, + CreateMappedArgumentsObject: { + url: 'https://262.ecma-international.org/15.0/#sec-createmappedargumentsobject' + }, + CreateNonEnumerableDataPropertyOrThrow: { + url: 'https://262.ecma-international.org/15.0/#sec-createnonenumerabledatapropertyorthrow' + }, + CreatePerIterationEnvironment: { + url: 'https://262.ecma-international.org/15.0/#sec-createperiterationenvironment' + }, + CreateRealm: { + url: 'https://262.ecma-international.org/15.0/#sec-createrealm' + }, + CreateRegExpStringIterator: { + url: 'https://262.ecma-international.org/15.0/#sec-createregexpstringiterator' + }, + CreateResolvingFunctions: { + url: 'https://262.ecma-international.org/15.0/#sec-createresolvingfunctions' + }, + CreateSetIterator: { + url: 'https://262.ecma-international.org/15.0/#sec-createsetiterator' + }, + CreateSharedByteDataBlock: { + url: 'https://262.ecma-international.org/15.0/#sec-createsharedbytedatablock' + }, + CreateUnmappedArgumentsObject: { + url: 'https://262.ecma-international.org/15.0/#sec-createunmappedargumentsobject' + }, + DateFromTime: { + url: 'https://262.ecma-international.org/15.0/#sec-datefromtime' + }, + DateString: { + url: 'https://262.ecma-international.org/15.0/#sec-datestring' + }, + Day: { + url: 'https://262.ecma-international.org/15.0/#sec-day' + }, + DayFromYear: { + url: 'https://262.ecma-international.org/15.0/#sec-dayfromyear' + }, + DaysInYear: { + url: 'https://262.ecma-international.org/15.0/#sec-daysinyear' + }, + DayWithinYear: { + url: 'https://262.ecma-international.org/15.0/#sec-daywithinyear' + }, + Decode: { + url: 'https://262.ecma-international.org/15.0/#sec-decode' + }, + DefineField: { + url: 'https://262.ecma-international.org/15.0/#sec-definefield' + }, + DefineMethodProperty: { + url: 'https://262.ecma-international.org/15.0/#sec-definemethodproperty' + }, + DefinePropertyOrThrow: { + url: 'https://262.ecma-international.org/15.0/#sec-definepropertyorthrow' + }, + DeletePropertyOrThrow: { + url: 'https://262.ecma-international.org/15.0/#sec-deletepropertyorthrow' + }, + DetachArrayBuffer: { + url: 'https://262.ecma-international.org/15.0/#sec-detacharraybuffer' + }, + DoWait: { + url: 'https://262.ecma-international.org/15.0/#sec-dowait' + }, + EmptyMatcher: { + url: 'https://262.ecma-international.org/15.0/#sec-emptymatcher' + }, + Encode: { + url: 'https://262.ecma-international.org/15.0/#sec-encode' + }, + EnqueueAtomicsWaitAsyncTimeoutJob: { + url: 'https://262.ecma-international.org/15.0/#sec-enqueueatomicswaitasynctimeoutjob' + }, + EnqueueResolveInAgentJob: { + url: 'https://262.ecma-international.org/15.0/#sec-enqueueresolveinagentjob' + }, + EnterCriticalSection: { + url: 'https://262.ecma-international.org/15.0/#sec-entercriticalsection' + }, + EnumerableOwnProperties: { + url: 'https://262.ecma-international.org/15.0/#sec-enumerableownproperties' + }, + EnumerateObjectProperties: { + url: 'https://262.ecma-international.org/15.0/#sec-enumerate-object-properties' + }, + EscapeRegExpPattern: { + url: 'https://262.ecma-international.org/15.0/#sec-escaperegexppattern' + }, + EvalDeclarationInstantiation: { + url: 'https://262.ecma-international.org/15.0/#sec-evaldeclarationinstantiation' + }, + EvaluateCall: { + url: 'https://262.ecma-international.org/15.0/#sec-evaluatecall' + }, + EvaluateNew: { + url: 'https://262.ecma-international.org/15.0/#sec-evaluatenew' + }, + EvaluatePropertyAccessWithExpressionKey: { + url: 'https://262.ecma-international.org/15.0/#sec-evaluate-property-access-with-expression-key' + }, + EvaluatePropertyAccessWithIdentifierKey: { + url: 'https://262.ecma-international.org/15.0/#sec-evaluate-property-access-with-identifier-key' + }, + EvaluateStringOrNumericBinaryExpression: { + url: 'https://262.ecma-international.org/15.0/#sec-evaluatestringornumericbinaryexpression' + }, + EventSet: { + url: 'https://262.ecma-international.org/15.0/#sec-event-set' + }, + ExecuteAsyncModule: { + url: 'https://262.ecma-international.org/15.0/#sec-execute-async-module' + }, + '𝔽': { + url: 'https://262.ecma-international.org/15.0/#𝔽' + }, + FindViaPredicate: { + url: 'https://262.ecma-international.org/15.0/#sec-findviapredicate' + }, + FinishLoadingImportedModule: { + url: 'https://262.ecma-international.org/15.0/#sec-FinishLoadingImportedModule' + }, + FlattenIntoArray: { + url: 'https://262.ecma-international.org/15.0/#sec-flattenintoarray' + }, + floor: { + url: 'https://262.ecma-international.org/15.0/#eqn-floor' + }, + ForBodyEvaluation: { + url: 'https://262.ecma-international.org/15.0/#sec-forbodyevaluation' + }, + 'ForIn/OfBodyEvaluation': { + url: 'https://262.ecma-international.org/15.0/#sec-runtime-semantics-forin-div-ofbodyevaluation-lhs-stmt-iterator-lhskind-labelset' + }, + 'ForIn/OfHeadEvaluation': { + url: 'https://262.ecma-international.org/15.0/#sec-runtime-semantics-forinofheadevaluation' + }, + FromPropertyDescriptor: { + url: 'https://262.ecma-international.org/15.0/#sec-frompropertydescriptor' + }, + FulfillPromise: { + url: 'https://262.ecma-international.org/15.0/#sec-fulfillpromise' + }, + FunctionDeclarationInstantiation: { + url: 'https://262.ecma-international.org/15.0/#sec-functiondeclarationinstantiation' + }, + GatherAvailableAncestors: { + url: 'https://262.ecma-international.org/15.0/#sec-gather-available-ancestors' + }, + GeneratorResume: { + url: 'https://262.ecma-international.org/15.0/#sec-generatorresume' + }, + GeneratorResumeAbrupt: { + url: 'https://262.ecma-international.org/15.0/#sec-generatorresumeabrupt' + }, + GeneratorStart: { + url: 'https://262.ecma-international.org/15.0/#sec-generatorstart' + }, + GeneratorValidate: { + url: 'https://262.ecma-international.org/15.0/#sec-generatorvalidate' + }, + GeneratorYield: { + url: 'https://262.ecma-international.org/15.0/#sec-generatoryield' + }, + Get: { + url: 'https://262.ecma-international.org/15.0/#sec-get-o-p' + }, + GetActiveScriptOrModule: { + url: 'https://262.ecma-international.org/15.0/#sec-getactivescriptormodule' + }, + GetArrayBufferMaxByteLengthOption: { + url: 'https://262.ecma-international.org/15.0/#sec-getarraybuffermaxbytelengthoption' + }, + GetFunctionRealm: { + url: 'https://262.ecma-international.org/15.0/#sec-getfunctionrealm' + }, + GetGeneratorKind: { + url: 'https://262.ecma-international.org/15.0/#sec-getgeneratorkind' + }, + GetGlobalObject: { + url: 'https://262.ecma-international.org/15.0/#sec-getglobalobject' + }, + GetIdentifierReference: { + url: 'https://262.ecma-international.org/15.0/#sec-getidentifierreference' + }, + GetImportedModule: { + url: 'https://262.ecma-international.org/15.0/#sec-GetImportedModule' + }, + GetIterator: { + url: 'https://262.ecma-international.org/15.0/#sec-getiterator' + }, + GetIteratorFromMethod: { + url: 'https://262.ecma-international.org/15.0/#sec-getiteratorfrommethod' + }, + GetMatchIndexPair: { + url: 'https://262.ecma-international.org/15.0/#sec-getmatchindexpair' + }, + GetMatchString: { + url: 'https://262.ecma-international.org/15.0/#sec-getmatchstring' + }, + GetMethod: { + url: 'https://262.ecma-international.org/15.0/#sec-getmethod' + }, + GetModifySetValueInBuffer: { + url: 'https://262.ecma-international.org/15.0/#sec-getmodifysetvalueinbuffer' + }, + GetModuleNamespace: { + url: 'https://262.ecma-international.org/15.0/#sec-getmodulenamespace' + }, + GetNamedTimeZoneEpochNanoseconds: { + url: 'https://262.ecma-international.org/15.0/#sec-getnamedtimezoneepochnanoseconds' + }, + GetNamedTimeZoneOffsetNanoseconds: { + url: 'https://262.ecma-international.org/15.0/#sec-getnamedtimezoneoffsetnanoseconds' + }, + GetNewTarget: { + url: 'https://262.ecma-international.org/15.0/#sec-getnewtarget' + }, + GetOwnPropertyKeys: { + url: 'https://262.ecma-international.org/15.0/#sec-getownpropertykeys' + }, + GetPromiseResolve: { + url: 'https://262.ecma-international.org/15.0/#sec-getpromiseresolve' + }, + GetPrototypeFromConstructor: { + url: 'https://262.ecma-international.org/15.0/#sec-getprototypefromconstructor' + }, + GetRawBytesFromSharedBlock: { + url: 'https://262.ecma-international.org/15.0/#sec-getrawbytesfromsharedblock' + }, + GetStringIndex: { + url: 'https://262.ecma-international.org/15.0/#sec-getstringindex' + }, + GetSubstitution: { + url: 'https://262.ecma-international.org/15.0/#sec-getsubstitution' + }, + GetSuperConstructor: { + url: 'https://262.ecma-international.org/15.0/#sec-getsuperconstructor' + }, + GetTemplateObject: { + url: 'https://262.ecma-international.org/15.0/#sec-gettemplateobject' + }, + GetThisEnvironment: { + url: 'https://262.ecma-international.org/15.0/#sec-getthisenvironment' + }, + GetThisValue: { + url: 'https://262.ecma-international.org/15.0/#sec-getthisvalue' + }, + GetUTCEpochNanoseconds: { + url: 'https://262.ecma-international.org/15.0/#sec-getutcepochnanoseconds' + }, + GetV: { + url: 'https://262.ecma-international.org/15.0/#sec-getv' + }, + GetValue: { + url: 'https://262.ecma-international.org/15.0/#sec-getvalue' + }, + GetValueFromBuffer: { + url: 'https://262.ecma-international.org/15.0/#sec-getvaluefrombuffer' + }, + GetViewByteLength: { + url: 'https://262.ecma-international.org/15.0/#sec-getviewbytelength' + }, + GetViewValue: { + url: 'https://262.ecma-international.org/15.0/#sec-getviewvalue' + }, + GetWaiterList: { + url: 'https://262.ecma-international.org/15.0/#sec-getwaiterlist' + }, + GlobalDeclarationInstantiation: { + url: 'https://262.ecma-international.org/15.0/#sec-globaldeclarationinstantiation' + }, + GroupBy: { + url: 'https://262.ecma-international.org/15.0/#sec-groupby' + }, + GroupSpecifiersThatMatch: { + url: 'https://262.ecma-international.org/15.0/#sec-groupspecifiersthatmatch' + }, + 'happens-before': { + url: 'https://262.ecma-international.org/15.0/#sec-happens-before' + }, + HasEitherUnicodeFlag: { + url: 'https://262.ecma-international.org/15.0/#sec-runtime-semantics-haseitherunicodeflag-abstract-operation' + }, + HasOwnProperty: { + url: 'https://262.ecma-international.org/15.0/#sec-hasownproperty' + }, + HasProperty: { + url: 'https://262.ecma-international.org/15.0/#sec-hasproperty' + }, + 'host-synchronizes-with': { + url: 'https://262.ecma-international.org/15.0/#sec-host-synchronizes-with' + }, + HostEventSet: { + url: 'https://262.ecma-international.org/15.0/#sec-hosteventset' + }, + HourFromTime: { + url: 'https://262.ecma-international.org/15.0/#sec-hourfromtime' + }, + IfAbruptCloseIterator: { + url: 'https://262.ecma-international.org/15.0/#sec-ifabruptcloseiterator' + }, + IfAbruptRejectPromise: { + url: 'https://262.ecma-international.org/15.0/#sec-ifabruptrejectpromise' + }, + ImportedLocalNames: { + url: 'https://262.ecma-international.org/15.0/#sec-importedlocalnames' + }, + InitializeBoundName: { + url: 'https://262.ecma-international.org/15.0/#sec-initializeboundname' + }, + InitializeHostDefinedRealm: { + url: 'https://262.ecma-international.org/15.0/#sec-initializehostdefinedrealm' + }, + InitializeInstanceElements: { + url: 'https://262.ecma-international.org/15.0/#sec-initializeinstanceelements' + }, + InitializeReferencedBinding: { + url: 'https://262.ecma-international.org/15.0/#sec-initializereferencedbinding' + }, + InitializeTypedArrayFromArrayBuffer: { + url: 'https://262.ecma-international.org/15.0/#sec-initializetypedarrayfromarraybuffer' + }, + InitializeTypedArrayFromArrayLike: { + url: 'https://262.ecma-international.org/15.0/#sec-initializetypedarrayfromarraylike' + }, + InitializeTypedArrayFromList: { + url: 'https://262.ecma-international.org/15.0/#sec-initializetypedarrayfromlist' + }, + InitializeTypedArrayFromTypedArray: { + url: 'https://262.ecma-international.org/15.0/#sec-initializetypedarrayfromtypedarray' + }, + InLeapYear: { + url: 'https://262.ecma-international.org/15.0/#sec-inleapyear' + }, + InnerModuleEvaluation: { + url: 'https://262.ecma-international.org/15.0/#sec-innermoduleevaluation' + }, + InnerModuleLinking: { + url: 'https://262.ecma-international.org/15.0/#sec-InnerModuleLinking' + }, + InnerModuleLoading: { + url: 'https://262.ecma-international.org/15.0/#sec-InnerModuleLoading' + }, + InstallErrorCause: { + url: 'https://262.ecma-international.org/15.0/#sec-installerrorcause' + }, + InstanceofOperator: { + url: 'https://262.ecma-international.org/15.0/#sec-instanceofoperator' + }, + InternalizeJSONProperty: { + url: 'https://262.ecma-international.org/15.0/#sec-internalizejsonproperty' + }, + Invoke: { + url: 'https://262.ecma-international.org/15.0/#sec-invoke' + }, + IsAccessorDescriptor: { + url: 'https://262.ecma-international.org/15.0/#sec-isaccessordescriptor' + }, + IsAnonymousFunctionDefinition: { + url: 'https://262.ecma-international.org/15.0/#sec-isanonymousfunctiondefinition' + }, + IsArray: { + url: 'https://262.ecma-international.org/15.0/#sec-isarray' + }, + IsArrayBufferViewOutOfBounds: { + url: 'https://262.ecma-international.org/15.0/#sec-isarraybufferviewoutofbounds' + }, + IsBigIntElementType: { + url: 'https://262.ecma-international.org/15.0/#sec-isbigintelementtype' + }, + IsCallable: { + url: 'https://262.ecma-international.org/15.0/#sec-iscallable' + }, + IsCompatiblePropertyDescriptor: { + url: 'https://262.ecma-international.org/15.0/#sec-iscompatiblepropertydescriptor' + }, + IsConcatSpreadable: { + url: 'https://262.ecma-international.org/15.0/#sec-isconcatspreadable' + }, + IsConstructor: { + url: 'https://262.ecma-international.org/15.0/#sec-isconstructor' + }, + IsDataDescriptor: { + url: 'https://262.ecma-international.org/15.0/#sec-isdatadescriptor' + }, + IsDetachedBuffer: { + url: 'https://262.ecma-international.org/15.0/#sec-isdetachedbuffer' + }, + IsExtensible: { + url: 'https://262.ecma-international.org/15.0/#sec-isextensible-o' + }, + IsFixedLengthArrayBuffer: { + url: 'https://262.ecma-international.org/15.0/#sec-isfixedlengtharraybuffer' + }, + IsGenericDescriptor: { + url: 'https://262.ecma-international.org/15.0/#sec-isgenericdescriptor' + }, + IsInTailPosition: { + url: 'https://262.ecma-international.org/15.0/#sec-isintailposition' + }, + IsIntegralNumber: { + url: 'https://262.ecma-international.org/15.0/#sec-isintegralnumber' + }, + IsLabelledFunction: { + url: 'https://262.ecma-international.org/15.0/#sec-islabelledfunction' + }, + IsLessThan: { + url: 'https://262.ecma-international.org/15.0/#sec-islessthan' + }, + IsLooselyEqual: { + url: 'https://262.ecma-international.org/15.0/#sec-islooselyequal' + }, + IsNoTearConfiguration: { + url: 'https://262.ecma-international.org/15.0/#sec-isnotearconfiguration' + }, + IsPrivateReference: { + url: 'https://262.ecma-international.org/15.0/#sec-isprivatereference' + }, + IsPromise: { + url: 'https://262.ecma-international.org/15.0/#sec-ispromise' + }, + IsPropertyKey: { + url: 'https://262.ecma-international.org/15.0/#sec-ispropertykey' + }, + IsPropertyReference: { + url: 'https://262.ecma-international.org/15.0/#sec-ispropertyreference' + }, + IsRegExp: { + url: 'https://262.ecma-international.org/15.0/#sec-isregexp' + }, + IsSharedArrayBuffer: { + url: 'https://262.ecma-international.org/15.0/#sec-issharedarraybuffer' + }, + IsStrictlyEqual: { + url: 'https://262.ecma-international.org/15.0/#sec-isstrictlyequal' + }, + IsStringWellFormedUnicode: { + url: 'https://262.ecma-international.org/15.0/#sec-isstringwellformedunicode' + }, + IsSuperReference: { + url: 'https://262.ecma-international.org/15.0/#sec-issuperreference' + }, + IsTimeZoneOffsetString: { + url: 'https://262.ecma-international.org/15.0/#sec-istimezoneoffsetstring' + }, + IsTypedArrayOutOfBounds: { + url: 'https://262.ecma-international.org/15.0/#sec-istypedarrayoutofbounds' + }, + IsUnclampedIntegerElementType: { + url: 'https://262.ecma-international.org/15.0/#sec-isunclampedintegerelementtype' + }, + IsUnresolvableReference: { + url: 'https://262.ecma-international.org/15.0/#sec-isunresolvablereference' + }, + IsUnsignedElementType: { + url: 'https://262.ecma-international.org/15.0/#sec-isunsignedelementtype' + }, + IsValidIntegerIndex: { + url: 'https://262.ecma-international.org/15.0/#sec-isvalidintegerindex' + }, + IsValidRegularExpressionLiteral: { + url: 'https://262.ecma-international.org/15.0/#sec-isvalidregularexpressionliteral' + }, + IsViewOutOfBounds: { + url: 'https://262.ecma-international.org/15.0/#sec-isviewoutofbounds' + }, + IsWordChar: { + url: 'https://262.ecma-international.org/15.0/#sec-runtime-semantics-iswordchar-abstract-operation' + }, + IteratorClose: { + url: 'https://262.ecma-international.org/15.0/#sec-iteratorclose' + }, + IteratorComplete: { + url: 'https://262.ecma-international.org/15.0/#sec-iteratorcomplete' + }, + IteratorNext: { + url: 'https://262.ecma-international.org/15.0/#sec-iteratornext' + }, + IteratorStep: { + url: 'https://262.ecma-international.org/15.0/#sec-iteratorstep' + }, + IteratorStepValue: { + url: 'https://262.ecma-international.org/15.0/#sec-iteratorstepvalue' + }, + IteratorToList: { + url: 'https://262.ecma-international.org/15.0/#sec-iteratortolist' + }, + IteratorValue: { + url: 'https://262.ecma-international.org/15.0/#sec-iteratorvalue' + }, + KeyForSymbol: { + url: 'https://262.ecma-international.org/15.0/#sec-keyforsymbol' + }, + LeaveCriticalSection: { + url: 'https://262.ecma-international.org/15.0/#sec-leavecriticalsection' + }, + LengthOfArrayLike: { + url: 'https://262.ecma-international.org/15.0/#sec-lengthofarraylike' + }, + LocalTime: { + url: 'https://262.ecma-international.org/15.0/#sec-localtime' + }, + LoopContinues: { + url: 'https://262.ecma-international.org/15.0/#sec-loopcontinues' + }, + MakeArgGetter: { + url: 'https://262.ecma-international.org/15.0/#sec-makearggetter' + }, + MakeArgSetter: { + url: 'https://262.ecma-international.org/15.0/#sec-makeargsetter' + }, + MakeBasicObject: { + url: 'https://262.ecma-international.org/15.0/#sec-makebasicobject' + }, + MakeClassConstructor: { + url: 'https://262.ecma-international.org/15.0/#sec-makeclassconstructor' + }, + MakeConstructor: { + url: 'https://262.ecma-international.org/15.0/#sec-makeconstructor' + }, + MakeDataViewWithBufferWitnessRecord: { + url: 'https://262.ecma-international.org/15.0/#sec-makedataviewwithbufferwitnessrecord' + }, + MakeDate: { + url: 'https://262.ecma-international.org/15.0/#sec-makedate' + }, + MakeDay: { + url: 'https://262.ecma-international.org/15.0/#sec-makeday' + }, + MakeFullYear: { + url: 'https://262.ecma-international.org/15.0/#sec-makefullyear' + }, + MakeMatchIndicesIndexPairArray: { + url: 'https://262.ecma-international.org/15.0/#sec-makematchindicesindexpairarray' + }, + MakeMethod: { + url: 'https://262.ecma-international.org/15.0/#sec-makemethod' + }, + MakePrivateReference: { + url: 'https://262.ecma-international.org/15.0/#sec-makeprivatereference' + }, + MakeSuperPropertyReference: { + url: 'https://262.ecma-international.org/15.0/#sec-makesuperpropertyreference' + }, + MakeTime: { + url: 'https://262.ecma-international.org/15.0/#sec-maketime' + }, + MakeTypedArrayWithBufferWitnessRecord: { + url: 'https://262.ecma-international.org/15.0/#sec-maketypedarraywithbufferwitnessrecord' + }, + MatchSequence: { + url: 'https://262.ecma-international.org/15.0/#sec-matchsequence' + }, + MatchTwoAlternatives: { + url: 'https://262.ecma-international.org/15.0/#sec-matchtwoalternatives' + }, + max: { + url: 'https://262.ecma-international.org/15.0/#eqn-max' + }, + MaybeSimpleCaseFolding: { + url: 'https://262.ecma-international.org/15.0/#sec-maybesimplecasefolding' + }, + 'memory-order': { + url: 'https://262.ecma-international.org/15.0/#sec-memory-order' + }, + min: { + url: 'https://262.ecma-international.org/15.0/#eqn-min' + }, + MinFromTime: { + url: 'https://262.ecma-international.org/15.0/#sec-minfromtime' + }, + ModuleNamespaceCreate: { + url: 'https://262.ecma-international.org/15.0/#sec-modulenamespacecreate' + }, + modulo: { + url: 'https://262.ecma-international.org/15.0/#eqn-modulo' + }, + MonthFromTime: { + url: 'https://262.ecma-international.org/15.0/#sec-monthfromtime' + }, + msFromTime: { + url: 'https://262.ecma-international.org/15.0/#sec-msfromtime' + }, + NewDeclarativeEnvironment: { + url: 'https://262.ecma-international.org/15.0/#sec-newdeclarativeenvironment' + }, + NewFunctionEnvironment: { + url: 'https://262.ecma-international.org/15.0/#sec-newfunctionenvironment' + }, + NewGlobalEnvironment: { + url: 'https://262.ecma-international.org/15.0/#sec-newglobalenvironment' + }, + NewModuleEnvironment: { + url: 'https://262.ecma-international.org/15.0/#sec-newmoduleenvironment' + }, + NewObjectEnvironment: { + url: 'https://262.ecma-international.org/15.0/#sec-newobjectenvironment' + }, + NewPrivateEnvironment: { + url: 'https://262.ecma-international.org/15.0/#sec-newprivateenvironment' + }, + NewPromiseCapability: { + url: 'https://262.ecma-international.org/15.0/#sec-newpromisecapability' + }, + NewPromiseReactionJob: { + url: 'https://262.ecma-international.org/15.0/#sec-newpromisereactionjob' + }, + NewPromiseResolveThenableJob: { + url: 'https://262.ecma-international.org/15.0/#sec-newpromiseresolvethenablejob' + }, + NormalCompletion: { + url: 'https://262.ecma-international.org/15.0/#sec-normalcompletion' + }, + NotifyWaiter: { + url: 'https://262.ecma-international.org/15.0/#sec-notifywaiter' + }, + 'Number::add': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-number-add' + }, + 'Number::bitwiseAND': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-number-bitwiseAND' + }, + 'Number::bitwiseNOT': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-number-bitwiseNOT' + }, + 'Number::bitwiseOR': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-number-bitwiseOR' + }, + 'Number::bitwiseXOR': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-number-bitwiseXOR' + }, + 'Number::divide': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-number-divide' + }, + 'Number::equal': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-number-equal' + }, + 'Number::exponentiate': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-number-exponentiate' + }, + 'Number::leftShift': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-number-leftShift' + }, + 'Number::lessThan': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-number-lessThan' + }, + 'Number::multiply': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-number-multiply' + }, + 'Number::remainder': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-number-remainder' + }, + 'Number::sameValue': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-number-sameValue' + }, + 'Number::sameValueZero': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-number-sameValueZero' + }, + 'Number::signedRightShift': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-number-signedRightShift' + }, + 'Number::subtract': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-number-subtract' + }, + 'Number::toString': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-number-tostring' + }, + 'Number::unaryMinus': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-number-unaryMinus' + }, + 'Number::unsignedRightShift': { + url: 'https://262.ecma-international.org/15.0/#sec-numeric-types-number-unsignedRightShift' + }, + NumberBitwiseOp: { + url: 'https://262.ecma-international.org/15.0/#sec-numberbitwiseop' + }, + NumberToBigInt: { + url: 'https://262.ecma-international.org/15.0/#sec-numbertobigint' + }, + NumericToRawBytes: { + url: 'https://262.ecma-international.org/15.0/#sec-numerictorawbytes' + }, + ObjectDefineProperties: { + url: 'https://262.ecma-international.org/15.0/#sec-objectdefineproperties' + }, + OrdinaryCallBindThis: { + url: 'https://262.ecma-international.org/15.0/#sec-ordinarycallbindthis' + }, + OrdinaryCallEvaluateBody: { + url: 'https://262.ecma-international.org/15.0/#sec-ordinarycallevaluatebody' + }, + OrdinaryCreateFromConstructor: { + url: 'https://262.ecma-international.org/15.0/#sec-ordinarycreatefromconstructor' + }, + OrdinaryDefineOwnProperty: { + url: 'https://262.ecma-international.org/15.0/#sec-ordinarydefineownproperty' + }, + OrdinaryDelete: { + url: 'https://262.ecma-international.org/15.0/#sec-ordinarydelete' + }, + OrdinaryFunctionCreate: { + url: 'https://262.ecma-international.org/15.0/#sec-ordinaryfunctioncreate' + }, + OrdinaryGet: { + url: 'https://262.ecma-international.org/15.0/#sec-ordinaryget' + }, + OrdinaryGetOwnProperty: { + url: 'https://262.ecma-international.org/15.0/#sec-ordinarygetownproperty' + }, + OrdinaryGetPrototypeOf: { + url: 'https://262.ecma-international.org/15.0/#sec-ordinarygetprototypeof' + }, + OrdinaryHasInstance: { + url: 'https://262.ecma-international.org/15.0/#sec-ordinaryhasinstance' + }, + OrdinaryHasProperty: { + url: 'https://262.ecma-international.org/15.0/#sec-ordinaryhasproperty' + }, + OrdinaryIsExtensible: { + url: 'https://262.ecma-international.org/15.0/#sec-ordinaryisextensible' + }, + OrdinaryObjectCreate: { + url: 'https://262.ecma-international.org/15.0/#sec-ordinaryobjectcreate' + }, + OrdinaryOwnPropertyKeys: { + url: 'https://262.ecma-international.org/15.0/#sec-ordinaryownpropertykeys' + }, + OrdinaryPreventExtensions: { + url: 'https://262.ecma-international.org/15.0/#sec-ordinarypreventextensions' + }, + OrdinarySet: { + url: 'https://262.ecma-international.org/15.0/#sec-ordinaryset' + }, + OrdinarySetPrototypeOf: { + url: 'https://262.ecma-international.org/15.0/#sec-ordinarysetprototypeof' + }, + OrdinarySetWithOwnDescriptor: { + url: 'https://262.ecma-international.org/15.0/#sec-ordinarysetwithowndescriptor' + }, + OrdinaryToPrimitive: { + url: 'https://262.ecma-international.org/15.0/#sec-ordinarytoprimitive' + }, + ParseHexOctet: { + url: 'https://262.ecma-international.org/15.0/#sec-parsehexoctet' + }, + ParseModule: { + url: 'https://262.ecma-international.org/15.0/#sec-parsemodule' + }, + ParsePattern: { + url: 'https://262.ecma-international.org/15.0/#sec-parsepattern' + }, + ParseScript: { + url: 'https://262.ecma-international.org/15.0/#sec-parse-script' + }, + ParseText: { + url: 'https://262.ecma-international.org/15.0/#sec-parsetext' + }, + ParseTimeZoneOffsetString: { + url: 'https://262.ecma-international.org/15.0/#sec-parsetimezoneoffsetstring' + }, + PerformEval: { + url: 'https://262.ecma-international.org/15.0/#sec-performeval' + }, + PerformPromiseAll: { + url: 'https://262.ecma-international.org/15.0/#sec-performpromiseall' + }, + PerformPromiseAllSettled: { + url: 'https://262.ecma-international.org/15.0/#sec-performpromiseallsettled' + }, + PerformPromiseAny: { + url: 'https://262.ecma-international.org/15.0/#sec-performpromiseany' + }, + PerformPromiseRace: { + url: 'https://262.ecma-international.org/15.0/#sec-performpromiserace' + }, + PerformPromiseThen: { + url: 'https://262.ecma-international.org/15.0/#sec-performpromisethen' + }, + PrepareForOrdinaryCall: { + url: 'https://262.ecma-international.org/15.0/#sec-prepareforordinarycall' + }, + PrepareForTailCall: { + url: 'https://262.ecma-international.org/15.0/#sec-preparefortailcall' + }, + PrivateElementFind: { + url: 'https://262.ecma-international.org/15.0/#sec-privateelementfind' + }, + PrivateFieldAdd: { + url: 'https://262.ecma-international.org/15.0/#sec-privatefieldadd' + }, + PrivateGet: { + url: 'https://262.ecma-international.org/15.0/#sec-privateget' + }, + PrivateMethodOrAccessorAdd: { + url: 'https://262.ecma-international.org/15.0/#sec-privatemethodoraccessoradd' + }, + PrivateSet: { + url: 'https://262.ecma-international.org/15.0/#sec-privateset' + }, + PromiseResolve: { + url: 'https://262.ecma-international.org/15.0/#sec-promise-resolve' + }, + ProxyCreate: { + url: 'https://262.ecma-international.org/15.0/#sec-proxycreate' + }, + PutValue: { + url: 'https://262.ecma-international.org/15.0/#sec-putvalue' + }, + QuoteJSONString: { + url: 'https://262.ecma-international.org/15.0/#sec-quotejsonstring' + }, + ℝ: { + url: 'https://262.ecma-international.org/15.0/#ℝ' + }, + RawBytesToNumeric: { + url: 'https://262.ecma-international.org/15.0/#sec-rawbytestonumeric' + }, + 'reads-bytes-from': { + url: 'https://262.ecma-international.org/15.0/#sec-reads-bytes-from' + }, + 'reads-from': { + url: 'https://262.ecma-international.org/15.0/#sec-reads-from' + }, + RegExpAlloc: { + url: 'https://262.ecma-international.org/15.0/#sec-regexpalloc' + }, + RegExpBuiltinExec: { + url: 'https://262.ecma-international.org/15.0/#sec-regexpbuiltinexec' + }, + RegExpCreate: { + url: 'https://262.ecma-international.org/15.0/#sec-regexpcreate' + }, + RegExpExec: { + url: 'https://262.ecma-international.org/15.0/#sec-regexpexec' + }, + RegExpHasFlag: { + url: 'https://262.ecma-international.org/15.0/#sec-regexphasflag' + }, + RegExpInitialize: { + url: 'https://262.ecma-international.org/15.0/#sec-regexpinitialize' + }, + RejectPromise: { + url: 'https://262.ecma-international.org/15.0/#sec-rejectpromise' + }, + RemoveWaiter: { + url: 'https://262.ecma-international.org/15.0/#sec-removewaiter' + }, + RemoveWaiters: { + url: 'https://262.ecma-international.org/15.0/#sec-removewaiters' + }, + RepeatMatcher: { + url: 'https://262.ecma-international.org/15.0/#sec-runtime-semantics-repeatmatcher-abstract-operation' + }, + RequireInternalSlot: { + url: 'https://262.ecma-international.org/15.0/#sec-requireinternalslot' + }, + RequireObjectCoercible: { + url: 'https://262.ecma-international.org/15.0/#sec-requireobjectcoercible' + }, + ResolveBinding: { + url: 'https://262.ecma-international.org/15.0/#sec-resolvebinding' + }, + ResolvePrivateIdentifier: { + url: 'https://262.ecma-international.org/15.0/#sec-resolve-private-identifier' + }, + ResolveThisBinding: { + url: 'https://262.ecma-international.org/15.0/#sec-resolvethisbinding' + }, + ReturnIfAbrupt: { + url: 'https://262.ecma-international.org/15.0/#sec-returnifabrupt' + }, + RevalidateAtomicAccess: { + url: 'https://262.ecma-international.org/15.0/#sec-revalidateatomicaccess' + }, + RoundMVResult: { + url: 'https://262.ecma-international.org/15.0/#sec-roundmvresult' + }, + SameValue: { + url: 'https://262.ecma-international.org/15.0/#sec-samevalue' + }, + SameValueNonNumber: { + url: 'https://262.ecma-international.org/15.0/#sec-samevaluenonnumber' + }, + SameValueZero: { + url: 'https://262.ecma-international.org/15.0/#sec-samevaluezero' + }, + scf: { + url: 'https://262.ecma-international.org/15.0/#eqn-scf' + }, + ScriptEvaluation: { + url: 'https://262.ecma-international.org/15.0/#sec-runtime-semantics-scriptevaluation' + }, + SecFromTime: { + url: 'https://262.ecma-international.org/15.0/#sec-secfromtime' + }, + SerializeJSONArray: { + url: 'https://262.ecma-international.org/15.0/#sec-serializejsonarray' + }, + SerializeJSONObject: { + url: 'https://262.ecma-international.org/15.0/#sec-serializejsonobject' + }, + SerializeJSONProperty: { + url: 'https://262.ecma-international.org/15.0/#sec-serializejsonproperty' + }, + Set: { + url: 'https://262.ecma-international.org/15.0/#sec-set-o-p-v-throw' + }, + SetDefaultGlobalBindings: { + url: 'https://262.ecma-international.org/15.0/#sec-setdefaultglobalbindings' + }, + SetFunctionLength: { + url: 'https://262.ecma-international.org/15.0/#sec-setfunctionlength' + }, + SetFunctionName: { + url: 'https://262.ecma-international.org/15.0/#sec-setfunctionname' + }, + SetImmutablePrototype: { + url: 'https://262.ecma-international.org/15.0/#sec-set-immutable-prototype' + }, + SetIntegrityLevel: { + url: 'https://262.ecma-international.org/15.0/#sec-setintegritylevel' + }, + SetRealmGlobalObject: { + url: 'https://262.ecma-international.org/15.0/#sec-setrealmglobalobject' + }, + SetTypedArrayFromArrayLike: { + url: 'https://262.ecma-international.org/15.0/#sec-settypedarrayfromarraylike' + }, + SetTypedArrayFromTypedArray: { + url: 'https://262.ecma-international.org/15.0/#sec-settypedarrayfromtypedarray' + }, + SetValueInBuffer: { + url: 'https://262.ecma-international.org/15.0/#sec-setvalueinbuffer' + }, + SetViewValue: { + url: 'https://262.ecma-international.org/15.0/#sec-setviewvalue' + }, + SharedDataBlockEventSet: { + url: 'https://262.ecma-international.org/15.0/#sec-sharedatablockeventset' + }, + SortIndexedProperties: { + url: 'https://262.ecma-international.org/15.0/#sec-sortindexedproperties' + }, + SpeciesConstructor: { + url: 'https://262.ecma-international.org/15.0/#sec-speciesconstructor' + }, + StringCreate: { + url: 'https://262.ecma-international.org/15.0/#sec-stringcreate' + }, + StringGetOwnProperty: { + url: 'https://262.ecma-international.org/15.0/#sec-stringgetownproperty' + }, + StringIndexOf: { + url: 'https://262.ecma-international.org/15.0/#sec-stringindexof' + }, + StringPad: { + url: 'https://262.ecma-international.org/15.0/#sec-stringpad' + }, + StringPaddingBuiltinsImpl: { + url: 'https://262.ecma-international.org/15.0/#sec-stringpaddingbuiltinsimpl' + }, + StringToBigInt: { + url: 'https://262.ecma-international.org/15.0/#sec-stringtobigint' + }, + StringToCodePoints: { + url: 'https://262.ecma-international.org/15.0/#sec-stringtocodepoints' + }, + StringToNumber: { + url: 'https://262.ecma-international.org/15.0/#sec-stringtonumber' + }, + substring: { + url: 'https://262.ecma-international.org/15.0/#substring' + }, + SuspendThisAgent: { + url: 'https://262.ecma-international.org/15.0/#sec-suspendthisagent' + }, + SymbolDescriptiveString: { + url: 'https://262.ecma-international.org/15.0/#sec-symboldescriptivestring' + }, + 'synchronizes-with': { + url: 'https://262.ecma-international.org/15.0/#sec-synchronizes-with' + }, + SystemTimeZoneIdentifier: { + url: 'https://262.ecma-international.org/15.0/#sec-systemtimezoneidentifier' + }, + TemplateString: { + url: 'https://262.ecma-international.org/15.0/#sec-templatestring' + }, + TestIntegrityLevel: { + url: 'https://262.ecma-international.org/15.0/#sec-testintegritylevel' + }, + ThisBigIntValue: { + url: 'https://262.ecma-international.org/15.0/#sec-thisbigintvalue' + }, + ThisBooleanValue: { + url: 'https://262.ecma-international.org/15.0/#sec-thisbooleanvalue' + }, + ThisNumberValue: { + url: 'https://262.ecma-international.org/15.0/#sec-thisnumbervalue' + }, + ThisStringValue: { + url: 'https://262.ecma-international.org/15.0/#sec-thisstringvalue' + }, + ThisSymbolValue: { + url: 'https://262.ecma-international.org/15.0/#sec-thissymbolvalue' + }, + ThrowCompletion: { + url: 'https://262.ecma-international.org/15.0/#sec-throwcompletion' + }, + TimeClip: { + url: 'https://262.ecma-international.org/15.0/#sec-timeclip' + }, + TimeFromYear: { + url: 'https://262.ecma-international.org/15.0/#sec-timefromyear' + }, + TimeString: { + url: 'https://262.ecma-international.org/15.0/#sec-timestring' + }, + TimeWithinDay: { + url: 'https://262.ecma-international.org/15.0/#sec-timewithinday' + }, + TimeZoneString: { + url: 'https://262.ecma-international.org/15.0/#sec-timezoneestring' + }, + ToBigInt: { + url: 'https://262.ecma-international.org/15.0/#sec-tobigint' + }, + ToBigInt64: { + url: 'https://262.ecma-international.org/15.0/#sec-tobigint64' + }, + ToBigUint64: { + url: 'https://262.ecma-international.org/15.0/#sec-tobiguint64' + }, + ToBoolean: { + url: 'https://262.ecma-international.org/15.0/#sec-toboolean' + }, + ToDateString: { + url: 'https://262.ecma-international.org/15.0/#sec-todatestring' + }, + ToIndex: { + url: 'https://262.ecma-international.org/15.0/#sec-toindex' + }, + ToInt16: { + url: 'https://262.ecma-international.org/15.0/#sec-toint16' + }, + ToInt32: { + url: 'https://262.ecma-international.org/15.0/#sec-toint32' + }, + ToInt8: { + url: 'https://262.ecma-international.org/15.0/#sec-toint8' + }, + ToIntegerOrInfinity: { + url: 'https://262.ecma-international.org/15.0/#sec-tointegerorinfinity' + }, + ToLength: { + url: 'https://262.ecma-international.org/15.0/#sec-tolength' + }, + ToNumber: { + url: 'https://262.ecma-international.org/15.0/#sec-tonumber' + }, + ToNumeric: { + url: 'https://262.ecma-international.org/15.0/#sec-tonumeric' + }, + ToObject: { + url: 'https://262.ecma-international.org/15.0/#sec-toobject' + }, + ToPrimitive: { + url: 'https://262.ecma-international.org/15.0/#sec-toprimitive' + }, + ToPropertyDescriptor: { + url: 'https://262.ecma-international.org/15.0/#sec-topropertydescriptor' + }, + ToPropertyKey: { + url: 'https://262.ecma-international.org/15.0/#sec-topropertykey' + }, + ToString: { + url: 'https://262.ecma-international.org/15.0/#sec-tostring' + }, + ToUint16: { + url: 'https://262.ecma-international.org/15.0/#sec-touint16' + }, + ToUint32: { + url: 'https://262.ecma-international.org/15.0/#sec-touint32' + }, + ToUint8: { + url: 'https://262.ecma-international.org/15.0/#sec-touint8' + }, + ToUint8Clamp: { + url: 'https://262.ecma-international.org/15.0/#sec-touint8clamp' + }, + ToZeroPaddedDecimalString: { + url: 'https://262.ecma-international.org/15.0/#sec-tozeropaddeddecimalstring' + }, + TriggerPromiseReactions: { + url: 'https://262.ecma-international.org/15.0/#sec-triggerpromisereactions' + }, + TrimString: { + url: 'https://262.ecma-international.org/15.0/#sec-trimstring' + }, + truncate: { + url: 'https://262.ecma-international.org/15.0/#eqn-truncate' + }, + Type: { + url: 'https://262.ecma-international.org/15.0/#sec-ecmascript-data-types-and-values' + }, + TypedArrayByteLength: { + url: 'https://262.ecma-international.org/15.0/#sec-typedarraybytelength' + }, + TypedArrayCreate: { + url: 'https://262.ecma-international.org/15.0/#sec-typedarraycreate' + }, + TypedArrayCreateFromConstructor: { + url: 'https://262.ecma-international.org/15.0/#sec-typedarraycreatefromconstructor' + }, + TypedArrayCreateSameType: { + url: 'https://262.ecma-international.org/15.0/#sec-typedarray-create-same-type' + }, + TypedArrayElementSize: { + url: 'https://262.ecma-international.org/15.0/#sec-typedarrayelementsize' + }, + TypedArrayElementType: { + url: 'https://262.ecma-international.org/15.0/#sec-typedarrayelementtype' + }, + TypedArrayGetElement: { + url: 'https://262.ecma-international.org/15.0/#sec-typedarraygetelement' + }, + TypedArrayLength: { + url: 'https://262.ecma-international.org/15.0/#sec-typedarraylength' + }, + TypedArraySetElement: { + url: 'https://262.ecma-international.org/15.0/#sec-typedarraysetelement' + }, + TypedArraySpeciesCreate: { + url: 'https://262.ecma-international.org/15.0/#typedarray-species-create' + }, + UnicodeEscape: { + url: 'https://262.ecma-international.org/15.0/#sec-unicodeescape' + }, + UnicodeMatchProperty: { + url: 'https://262.ecma-international.org/15.0/#sec-runtime-semantics-unicodematchproperty-p' + }, + UnicodeMatchPropertyValue: { + url: 'https://262.ecma-international.org/15.0/#sec-runtime-semantics-unicodematchpropertyvalue-p-v' + }, + UpdateEmpty: { + url: 'https://262.ecma-international.org/15.0/#sec-updateempty' + }, + UTC: { + url: 'https://262.ecma-international.org/15.0/#sec-utc-t' + }, + UTF16EncodeCodePoint: { + url: 'https://262.ecma-international.org/15.0/#sec-utf16encodecodepoint' + }, + UTF16SurrogatePairToCodePoint: { + url: 'https://262.ecma-international.org/15.0/#sec-utf16decodesurrogatepair' + }, + ValidateAndApplyPropertyDescriptor: { + url: 'https://262.ecma-international.org/15.0/#sec-validateandapplypropertydescriptor' + }, + ValidateAtomicAccess: { + url: 'https://262.ecma-international.org/15.0/#sec-validateatomicaccess' + }, + ValidateAtomicAccessOnIntegerTypedArray: { + url: 'https://262.ecma-international.org/15.0/#sec-validateatomicaccessonintegertypedarray' + }, + ValidateIntegerTypedArray: { + url: 'https://262.ecma-international.org/15.0/#sec-validateintegertypedarray' + }, + ValidateNonRevokedProxy: { + url: 'https://262.ecma-international.org/15.0/#sec-validatenonrevokedproxy' + }, + ValidateTypedArray: { + url: 'https://262.ecma-international.org/15.0/#sec-validatetypedarray' + }, + ValueOfReadEvent: { + url: 'https://262.ecma-international.org/15.0/#sec-valueofreadevent' + }, + WeakRefDeref: { + url: 'https://262.ecma-international.org/15.0/#sec-weakrefderef' + }, + WeekDay: { + url: 'https://262.ecma-international.org/15.0/#sec-weekday' + }, + WordCharacters: { + url: 'https://262.ecma-international.org/15.0/#sec-wordcharacters' + }, + YearFromTime: { + url: 'https://262.ecma-international.org/15.0/#sec-yearfromtime' + }, + Yield: { + url: 'https://262.ecma-international.org/15.0/#sec-yield' + }, + ℤ: { + url: 'https://262.ecma-international.org/15.0/#ℤ' + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2025.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2025.js new file mode 100644 index 0000000000000000000000000000000000000000..394acc2756d7ee3260a524879b2177eb5927c831 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/2025.js @@ -0,0 +1,1603 @@ +'use strict'; + +module.exports = { + abs: { + url: 'https://262.ecma-international.org/16.0/#eqn-abs' + }, + AddEntriesFromIterable: { + url: 'https://262.ecma-international.org/16.0/#sec-add-entries-from-iterable' + }, + AddRestrictedFunctionProperties: { + url: 'https://262.ecma-international.org/16.0/#sec-addrestrictedfunctionproperties' + }, + AddToKeptObjects: { + url: 'https://262.ecma-international.org/16.0/#sec-addtokeptobjects' + }, + AddValueToKeyedGroup: { + url: 'https://262.ecma-international.org/16.0/#sec-add-value-to-keyed-group' + }, + AddWaiter: { + url: 'https://262.ecma-international.org/16.0/#sec-addwaiter' + }, + AdvanceStringIndex: { + url: 'https://262.ecma-international.org/16.0/#sec-advancestringindex' + }, + AgentCanSuspend: { + url: 'https://262.ecma-international.org/16.0/#sec-agentcansuspend' + }, + AgentSignifier: { + url: 'https://262.ecma-international.org/16.0/#sec-agentsignifier' + }, + AllCharacters: { + url: 'https://262.ecma-international.org/16.0/#sec-allcharacters' + }, + AllImportAttributesSupported: { + url: 'https://262.ecma-international.org/16.0/#sec-AllImportAttributesSupported' + }, + AllocateArrayBuffer: { + url: 'https://262.ecma-international.org/16.0/#sec-allocatearraybuffer' + }, + AllocateSharedArrayBuffer: { + url: 'https://262.ecma-international.org/16.0/#sec-allocatesharedarraybuffer' + }, + AllocateTypedArray: { + url: 'https://262.ecma-international.org/16.0/#sec-allocatetypedarray' + }, + AllocateTypedArrayBuffer: { + url: 'https://262.ecma-international.org/16.0/#sec-allocatetypedarraybuffer' + }, + ApplyStringOrNumericBinaryOperator: { + url: 'https://262.ecma-international.org/16.0/#sec-applystringornumericbinaryoperator' + }, + ArrayBufferByteLength: { + url: 'https://262.ecma-international.org/16.0/#sec-arraybufferbytelength' + }, + ArrayBufferCopyAndDetach: { + url: 'https://262.ecma-international.org/16.0/#sec-arraybuffercopyanddetach' + }, + ArrayCreate: { + url: 'https://262.ecma-international.org/16.0/#sec-arraycreate' + }, + ArraySetLength: { + url: 'https://262.ecma-international.org/16.0/#sec-arraysetlength' + }, + ArraySpeciesCreate: { + url: 'https://262.ecma-international.org/16.0/#sec-arrayspeciescreate' + }, + AsyncBlockStart: { + url: 'https://262.ecma-international.org/16.0/#sec-asyncblockstart' + }, + AsyncFromSyncIteratorContinuation: { + url: 'https://262.ecma-international.org/16.0/#sec-asyncfromsynciteratorcontinuation' + }, + AsyncFunctionStart: { + url: 'https://262.ecma-international.org/16.0/#sec-async-functions-abstract-operations-async-function-start' + }, + AsyncGeneratorAwaitReturn: { + url: 'https://262.ecma-international.org/16.0/#sec-asyncgeneratorawaitreturn' + }, + AsyncGeneratorCompleteStep: { + url: 'https://262.ecma-international.org/16.0/#sec-asyncgeneratorcompletestep' + }, + AsyncGeneratorDrainQueue: { + url: 'https://262.ecma-international.org/16.0/#sec-asyncgeneratordrainqueue' + }, + AsyncGeneratorEnqueue: { + url: 'https://262.ecma-international.org/16.0/#sec-asyncgeneratorenqueue' + }, + AsyncGeneratorResume: { + url: 'https://262.ecma-international.org/16.0/#sec-asyncgeneratorresume' + }, + AsyncGeneratorStart: { + url: 'https://262.ecma-international.org/16.0/#sec-asyncgeneratorstart' + }, + AsyncGeneratorUnwrapYieldResumption: { + url: 'https://262.ecma-international.org/16.0/#sec-asyncgeneratorunwrapyieldresumption' + }, + AsyncGeneratorValidate: { + url: 'https://262.ecma-international.org/16.0/#sec-asyncgeneratorvalidate' + }, + AsyncGeneratorYield: { + url: 'https://262.ecma-international.org/16.0/#sec-asyncgeneratoryield' + }, + AsyncIteratorClose: { + url: 'https://262.ecma-international.org/16.0/#sec-asynciteratorclose' + }, + AsyncModuleExecutionFulfilled: { + url: 'https://262.ecma-international.org/16.0/#sec-async-module-execution-fulfilled' + }, + AsyncModuleExecutionRejected: { + url: 'https://262.ecma-international.org/16.0/#sec-async-module-execution-rejected' + }, + AtomicCompareExchangeInSharedBlock: { + url: 'https://262.ecma-international.org/16.0/#sec-atomiccompareexchangeinsharedblock' + }, + AtomicReadModifyWrite: { + url: 'https://262.ecma-international.org/16.0/#sec-atomicreadmodifywrite' + }, + AvailableNamedTimeZoneIdentifiers: { + url: 'https://262.ecma-international.org/16.0/#sec-availablenamedtimezoneidentifiers' + }, + Await: { + url: 'https://262.ecma-international.org/16.0/#await' + }, + BackreferenceMatcher: { + url: 'https://262.ecma-international.org/16.0/#sec-backreference-matcher' + }, + 'BigInt::add': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-bigint-add' + }, + 'BigInt::bitwiseAND': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-bigint-bitwiseAND' + }, + 'BigInt::bitwiseNOT': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-bigint-bitwiseNOT' + }, + 'BigInt::bitwiseOR': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-bigint-bitwiseOR' + }, + 'BigInt::bitwiseXOR': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-bigint-bitwiseXOR' + }, + 'BigInt::divide': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-bigint-divide' + }, + 'BigInt::equal': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-bigint-equal' + }, + 'BigInt::exponentiate': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-bigint-exponentiate' + }, + 'BigInt::leftShift': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-bigint-leftShift' + }, + 'BigInt::lessThan': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-bigint-lessThan' + }, + 'BigInt::multiply': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-bigint-multiply' + }, + 'BigInt::remainder': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-bigint-remainder' + }, + 'BigInt::signedRightShift': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-bigint-signedRightShift' + }, + 'BigInt::subtract': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-bigint-subtract' + }, + 'BigInt::toString': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-bigint-tostring' + }, + 'BigInt::unaryMinus': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-bigint-unaryMinus' + }, + 'BigInt::unsignedRightShift': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-bigint-unsignedRightShift' + }, + BigIntBitwiseOp: { + url: 'https://262.ecma-international.org/16.0/#sec-bigintbitwiseop' + }, + BinaryAnd: { + url: 'https://262.ecma-international.org/16.0/#sec-binaryand' + }, + BinaryOr: { + url: 'https://262.ecma-international.org/16.0/#sec-binaryor' + }, + BinaryXor: { + url: 'https://262.ecma-international.org/16.0/#sec-binaryxor' + }, + BindThisValue: { + url: 'https://262.ecma-international.org/16.0/#sec-bindthisvalue' + }, + BlockDeclarationInstantiation: { + url: 'https://262.ecma-international.org/16.0/#sec-blockdeclarationinstantiation' + }, + BoundFunctionCreate: { + url: 'https://262.ecma-international.org/16.0/#sec-boundfunctioncreate' + }, + BuiltinCallOrConstruct: { + url: 'https://262.ecma-international.org/16.0/#sec-builtincallorconstruct' + }, + ByteListBitwiseOp: { + url: 'https://262.ecma-international.org/16.0/#sec-bytelistbitwiseop' + }, + ByteListEqual: { + url: 'https://262.ecma-international.org/16.0/#sec-bytelistequal' + }, + Call: { + url: 'https://262.ecma-international.org/16.0/#sec-call' + }, + CanBeHeldWeakly: { + url: 'https://262.ecma-international.org/16.0/#sec-canbeheldweakly' + }, + CanDeclareGlobalFunction: { + url: 'https://262.ecma-international.org/16.0/#sec-candeclareglobalfunction' + }, + CanDeclareGlobalVar: { + url: 'https://262.ecma-international.org/16.0/#sec-candeclareglobalvar' + }, + Canonicalize: { + url: 'https://262.ecma-international.org/16.0/#sec-runtime-semantics-canonicalize-ch' + }, + CanonicalizeKeyedCollectionKey: { + url: 'https://262.ecma-international.org/16.0/#sec-canonicalizekeyedcollectionkey' + }, + CanonicalNumericIndexString: { + url: 'https://262.ecma-international.org/16.0/#sec-canonicalnumericindexstring' + }, + CaseClauseIsSelected: { + url: 'https://262.ecma-international.org/16.0/#sec-runtime-semantics-caseclauseisselected' + }, + CharacterComplement: { + url: 'https://262.ecma-international.org/16.0/#sec-charactercomplement' + }, + CharacterRange: { + url: 'https://262.ecma-international.org/16.0/#sec-runtime-semantics-characterrange-abstract-operation' + }, + CharacterRangeOrUnion: { + url: 'https://262.ecma-international.org/16.0/#sec-runtime-semantics-characterrangeorunion-abstract-operation' + }, + CharacterSetMatcher: { + url: 'https://262.ecma-international.org/16.0/#sec-runtime-semantics-charactersetmatcher-abstract-operation' + }, + clamp: { + url: 'https://262.ecma-international.org/16.0/#clamping' + }, + CleanupFinalizationRegistry: { + url: 'https://262.ecma-international.org/16.0/#sec-cleanup-finalization-registry' + }, + ClearKeptObjects: { + url: 'https://262.ecma-international.org/16.0/#sec-clear-kept-objects' + }, + CloneArrayBuffer: { + url: 'https://262.ecma-international.org/16.0/#sec-clonearraybuffer' + }, + CodePointAt: { + url: 'https://262.ecma-international.org/16.0/#sec-codepointat' + }, + CodePointsToString: { + url: 'https://262.ecma-international.org/16.0/#sec-codepointstostring' + }, + CompareArrayElements: { + url: 'https://262.ecma-international.org/16.0/#sec-comparearrayelements' + }, + CompareTypedArrayElements: { + url: 'https://262.ecma-international.org/16.0/#sec-comparetypedarrayelements' + }, + CompletePropertyDescriptor: { + url: 'https://262.ecma-international.org/16.0/#sec-completepropertydescriptor' + }, + Completion: { + url: 'https://262.ecma-international.org/16.0/#sec-completion-ao' + }, + CompletionRecord: { + url: 'https://262.ecma-international.org/16.0/#sec-completion-record-specification-type' + }, + ComposeWriteEventBytes: { + url: 'https://262.ecma-international.org/16.0/#sec-composewriteeventbytes' + }, + Construct: { + url: 'https://262.ecma-international.org/16.0/#sec-construct' + }, + ContinueDynamicImport: { + url: 'https://262.ecma-international.org/16.0/#sec-ContinueDynamicImport' + }, + ContinueModuleLoading: { + url: 'https://262.ecma-international.org/16.0/#sec-ContinueModuleLoading' + }, + CopyDataBlockBytes: { + url: 'https://262.ecma-international.org/16.0/#sec-copydatablockbytes' + }, + CopyDataProperties: { + url: 'https://262.ecma-international.org/16.0/#sec-copydataproperties' + }, + CountLeftCapturingParensBefore: { + url: 'https://262.ecma-international.org/16.0/#sec-countleftcapturingparensbefore' + }, + CountLeftCapturingParensWithin: { + url: 'https://262.ecma-international.org/16.0/#sec-countleftcapturingparenswithin' + }, + CreateArrayFromList: { + url: 'https://262.ecma-international.org/16.0/#sec-createarrayfromlist' + }, + CreateArrayIterator: { + url: 'https://262.ecma-international.org/16.0/#sec-createarrayiterator' + }, + CreateAsyncFromSyncIterator: { + url: 'https://262.ecma-international.org/16.0/#sec-createasyncfromsynciterator' + }, + CreateAsyncIteratorFromClosure: { + url: 'https://262.ecma-international.org/16.0/#sec-createasynciteratorfromclosure' + }, + CreateBuiltinFunction: { + url: 'https://262.ecma-international.org/16.0/#sec-createbuiltinfunction' + }, + CreateByteDataBlock: { + url: 'https://262.ecma-international.org/16.0/#sec-createbytedatablock' + }, + CreateDataProperty: { + url: 'https://262.ecma-international.org/16.0/#sec-createdataproperty' + }, + CreateDataPropertyOrThrow: { + url: 'https://262.ecma-international.org/16.0/#sec-createdatapropertyorthrow' + }, + CreateDefaultExportSyntheticModule: { + url: 'https://262.ecma-international.org/16.0/#sec-create-default-export-synthetic-module' + }, + CreateDynamicFunction: { + url: 'https://262.ecma-international.org/16.0/#sec-createdynamicfunction' + }, + CreateForInIterator: { + url: 'https://262.ecma-international.org/16.0/#sec-createforiniterator' + }, + CreateGlobalFunctionBinding: { + url: 'https://262.ecma-international.org/16.0/#sec-createglobalfunctionbinding' + }, + CreateGlobalVarBinding: { + url: 'https://262.ecma-international.org/16.0/#sec-createglobalvarbinding' + }, + CreateHTML: { + url: 'https://262.ecma-international.org/16.0/#sec-createhtml' + }, + CreateImportBinding: { + url: 'https://262.ecma-international.org/16.0/#sec-createimportbinding' + }, + CreateIntrinsics: { + url: 'https://262.ecma-international.org/16.0/#sec-createintrinsics' + }, + CreateIteratorFromClosure: { + url: 'https://262.ecma-international.org/16.0/#sec-createiteratorfromclosure' + }, + CreateIteratorResultObject: { + url: 'https://262.ecma-international.org/16.0/#sec-createiterresultobject' + }, + CreateListFromArrayLike: { + url: 'https://262.ecma-international.org/16.0/#sec-createlistfromarraylike' + }, + CreateListIteratorRecord: { + url: 'https://262.ecma-international.org/16.0/#sec-createlistiteratorRecord' + }, + CreateMapIterator: { + url: 'https://262.ecma-international.org/16.0/#sec-createmapiterator' + }, + CreateMappedArgumentsObject: { + url: 'https://262.ecma-international.org/16.0/#sec-createmappedargumentsobject' + }, + CreateNonEnumerableDataPropertyOrThrow: { + url: 'https://262.ecma-international.org/16.0/#sec-createnonenumerabledatapropertyorthrow' + }, + CreatePerIterationEnvironment: { + url: 'https://262.ecma-international.org/16.0/#sec-createperiterationenvironment' + }, + CreateRegExpStringIterator: { + url: 'https://262.ecma-international.org/16.0/#sec-createregexpstringiterator' + }, + CreateResolvingFunctions: { + url: 'https://262.ecma-international.org/16.0/#sec-createresolvingfunctions' + }, + CreateSetIterator: { + url: 'https://262.ecma-international.org/16.0/#sec-createsetiterator' + }, + CreateSharedByteDataBlock: { + url: 'https://262.ecma-international.org/16.0/#sec-createsharedbytedatablock' + }, + CreateUnmappedArgumentsObject: { + url: 'https://262.ecma-international.org/16.0/#sec-createunmappedargumentsobject' + }, + DateFromTime: { + url: 'https://262.ecma-international.org/16.0/#sec-datefromtime' + }, + DateString: { + url: 'https://262.ecma-international.org/16.0/#sec-datestring' + }, + Day: { + url: 'https://262.ecma-international.org/16.0/#sec-day' + }, + DayFromYear: { + url: 'https://262.ecma-international.org/16.0/#sec-dayfromyear' + }, + DaysInYear: { + url: 'https://262.ecma-international.org/16.0/#sec-daysinyear' + }, + DayWithinYear: { + url: 'https://262.ecma-international.org/16.0/#sec-daywithinyear' + }, + Decode: { + url: 'https://262.ecma-international.org/16.0/#sec-decode' + }, + DefineField: { + url: 'https://262.ecma-international.org/16.0/#sec-definefield' + }, + DefineMethodProperty: { + url: 'https://262.ecma-international.org/16.0/#sec-definemethodproperty' + }, + DefinePropertyOrThrow: { + url: 'https://262.ecma-international.org/16.0/#sec-definepropertyorthrow' + }, + DeletePropertyOrThrow: { + url: 'https://262.ecma-international.org/16.0/#sec-deletepropertyorthrow' + }, + DetachArrayBuffer: { + url: 'https://262.ecma-international.org/16.0/#sec-detacharraybuffer' + }, + DoWait: { + url: 'https://262.ecma-international.org/16.0/#sec-dowait' + }, + EmptyMatcher: { + url: 'https://262.ecma-international.org/16.0/#sec-emptymatcher' + }, + Encode: { + url: 'https://262.ecma-international.org/16.0/#sec-encode' + }, + EncodeForRegExpEscape: { + url: 'https://262.ecma-international.org/16.0/#sec-encodeforregexpescape' + }, + EnqueueAtomicsWaitAsyncTimeoutJob: { + url: 'https://262.ecma-international.org/16.0/#sec-enqueueatomicswaitasynctimeoutjob' + }, + EnqueueResolveInAgentJob: { + url: 'https://262.ecma-international.org/16.0/#sec-enqueueresolveinagentjob' + }, + EnterCriticalSection: { + url: 'https://262.ecma-international.org/16.0/#sec-entercriticalsection' + }, + EnumerableOwnProperties: { + url: 'https://262.ecma-international.org/16.0/#sec-enumerableownproperties' + }, + EnumerateObjectProperties: { + url: 'https://262.ecma-international.org/16.0/#sec-enumerate-object-properties' + }, + EscapeRegExpPattern: { + url: 'https://262.ecma-international.org/16.0/#sec-escaperegexppattern' + }, + EvalDeclarationInstantiation: { + url: 'https://262.ecma-international.org/16.0/#sec-evaldeclarationinstantiation' + }, + EvaluateCall: { + url: 'https://262.ecma-international.org/16.0/#sec-evaluatecall' + }, + EvaluateImportCall: { + url: 'https://262.ecma-international.org/16.0/#sec-evaluate-import-call' + }, + EvaluateNew: { + url: 'https://262.ecma-international.org/16.0/#sec-evaluatenew' + }, + EvaluatePropertyAccessWithExpressionKey: { + url: 'https://262.ecma-international.org/16.0/#sec-evaluate-property-access-with-expression-key' + }, + EvaluatePropertyAccessWithIdentifierKey: { + url: 'https://262.ecma-international.org/16.0/#sec-evaluate-property-access-with-identifier-key' + }, + EvaluateStringOrNumericBinaryExpression: { + url: 'https://262.ecma-international.org/16.0/#sec-evaluatestringornumericbinaryexpression' + }, + EventSet: { + url: 'https://262.ecma-international.org/16.0/#sec-event-set' + }, + ExecuteAsyncModule: { + url: 'https://262.ecma-international.org/16.0/#sec-execute-async-module' + }, + '𝔽': { + url: 'https://262.ecma-international.org/16.0/#𝔽' + }, + FindViaPredicate: { + url: 'https://262.ecma-international.org/16.0/#sec-findviapredicate' + }, + FinishLoadingImportedModule: { + url: 'https://262.ecma-international.org/16.0/#sec-FinishLoadingImportedModule' + }, + FlattenIntoArray: { + url: 'https://262.ecma-international.org/16.0/#sec-flattenintoarray' + }, + floor: { + url: 'https://262.ecma-international.org/16.0/#eqn-floor' + }, + ForBodyEvaluation: { + url: 'https://262.ecma-international.org/16.0/#sec-forbodyevaluation' + }, + 'ForIn/OfBodyEvaluation': { + url: 'https://262.ecma-international.org/16.0/#sec-runtime-semantics-forin-div-ofbodyevaluation-lhs-stmt-iterator-lhskind-labelset' + }, + 'ForIn/OfHeadEvaluation': { + url: 'https://262.ecma-international.org/16.0/#sec-runtime-semantics-forinofheadevaluation' + }, + FromPropertyDescriptor: { + url: 'https://262.ecma-international.org/16.0/#sec-frompropertydescriptor' + }, + FulfillPromise: { + url: 'https://262.ecma-international.org/16.0/#sec-fulfillpromise' + }, + FunctionDeclarationInstantiation: { + url: 'https://262.ecma-international.org/16.0/#sec-functiondeclarationinstantiation' + }, + GatherAvailableAncestors: { + url: 'https://262.ecma-international.org/16.0/#sec-gather-available-ancestors' + }, + GeneratorResume: { + url: 'https://262.ecma-international.org/16.0/#sec-generatorresume' + }, + GeneratorResumeAbrupt: { + url: 'https://262.ecma-international.org/16.0/#sec-generatorresumeabrupt' + }, + GeneratorStart: { + url: 'https://262.ecma-international.org/16.0/#sec-generatorstart' + }, + GeneratorValidate: { + url: 'https://262.ecma-international.org/16.0/#sec-generatorvalidate' + }, + GeneratorYield: { + url: 'https://262.ecma-international.org/16.0/#sec-generatoryield' + }, + Get: { + url: 'https://262.ecma-international.org/16.0/#sec-get-o-p' + }, + GetActiveScriptOrModule: { + url: 'https://262.ecma-international.org/16.0/#sec-getactivescriptormodule' + }, + GetArrayBufferMaxByteLengthOption: { + url: 'https://262.ecma-international.org/16.0/#sec-getarraybuffermaxbytelengthoption' + }, + GetFunctionRealm: { + url: 'https://262.ecma-international.org/16.0/#sec-getfunctionrealm' + }, + GetGeneratorKind: { + url: 'https://262.ecma-international.org/16.0/#sec-getgeneratorkind' + }, + GetGlobalObject: { + url: 'https://262.ecma-international.org/16.0/#sec-getglobalobject' + }, + GetIdentifierReference: { + url: 'https://262.ecma-international.org/16.0/#sec-getidentifierreference' + }, + GetImportedModule: { + url: 'https://262.ecma-international.org/16.0/#sec-GetImportedModule' + }, + GetIterator: { + url: 'https://262.ecma-international.org/16.0/#sec-getiterator' + }, + GetIteratorDirect: { + url: 'https://262.ecma-international.org/16.0/#sec-getiteratordirect' + }, + GetIteratorFlattenable: { + url: 'https://262.ecma-international.org/16.0/#sec-getiteratorflattenable' + }, + GetIteratorFromMethod: { + url: 'https://262.ecma-international.org/16.0/#sec-getiteratorfrommethod' + }, + GetMatchIndexPair: { + url: 'https://262.ecma-international.org/16.0/#sec-getmatchindexpair' + }, + GetMatchString: { + url: 'https://262.ecma-international.org/16.0/#sec-getmatchstring' + }, + GetMethod: { + url: 'https://262.ecma-international.org/16.0/#sec-getmethod' + }, + GetModifySetValueInBuffer: { + url: 'https://262.ecma-international.org/16.0/#sec-getmodifysetvalueinbuffer' + }, + GetModuleNamespace: { + url: 'https://262.ecma-international.org/16.0/#sec-getmodulenamespace' + }, + GetNamedTimeZoneEpochNanoseconds: { + url: 'https://262.ecma-international.org/16.0/#sec-getnamedtimezoneepochnanoseconds' + }, + GetNamedTimeZoneOffsetNanoseconds: { + url: 'https://262.ecma-international.org/16.0/#sec-getnamedtimezoneoffsetnanoseconds' + }, + GetNewTarget: { + url: 'https://262.ecma-international.org/16.0/#sec-getnewtarget' + }, + GetOwnPropertyKeys: { + url: 'https://262.ecma-international.org/16.0/#sec-getownpropertykeys' + }, + GetPromiseResolve: { + url: 'https://262.ecma-international.org/16.0/#sec-getpromiseresolve' + }, + GetPrototypeFromConstructor: { + url: 'https://262.ecma-international.org/16.0/#sec-getprototypefromconstructor' + }, + GetRawBytesFromSharedBlock: { + url: 'https://262.ecma-international.org/16.0/#sec-getrawbytesfromsharedblock' + }, + GetSetRecord: { + url: 'https://262.ecma-international.org/16.0/#sec-getsetrecord' + }, + GetStringIndex: { + url: 'https://262.ecma-international.org/16.0/#sec-getstringindex' + }, + GetSubstitution: { + url: 'https://262.ecma-international.org/16.0/#sec-getsubstitution' + }, + GetSuperBase: { + url: 'https://262.ecma-international.org/16.0/#sec-getsuperbase' + }, + GetSuperConstructor: { + url: 'https://262.ecma-international.org/16.0/#sec-getsuperconstructor' + }, + GetTemplateObject: { + url: 'https://262.ecma-international.org/16.0/#sec-gettemplateobject' + }, + GetThisEnvironment: { + url: 'https://262.ecma-international.org/16.0/#sec-getthisenvironment' + }, + GetThisValue: { + url: 'https://262.ecma-international.org/16.0/#sec-getthisvalue' + }, + GetUTCEpochNanoseconds: { + url: 'https://262.ecma-international.org/16.0/#sec-getutcepochnanoseconds' + }, + GetV: { + url: 'https://262.ecma-international.org/16.0/#sec-getv' + }, + GetValue: { + url: 'https://262.ecma-international.org/16.0/#sec-getvalue' + }, + GetValueFromBuffer: { + url: 'https://262.ecma-international.org/16.0/#sec-getvaluefrombuffer' + }, + GetViewByteLength: { + url: 'https://262.ecma-international.org/16.0/#sec-getviewbytelength' + }, + GetViewValue: { + url: 'https://262.ecma-international.org/16.0/#sec-getviewvalue' + }, + GetWaiterList: { + url: 'https://262.ecma-international.org/16.0/#sec-getwaiterlist' + }, + GlobalDeclarationInstantiation: { + url: 'https://262.ecma-international.org/16.0/#sec-globaldeclarationinstantiation' + }, + GroupBy: { + url: 'https://262.ecma-international.org/16.0/#sec-groupby' + }, + GroupSpecifiersThatMatch: { + url: 'https://262.ecma-international.org/16.0/#sec-groupspecifiersthatmatch' + }, + HasEitherUnicodeFlag: { + url: 'https://262.ecma-international.org/16.0/#sec-runtime-semantics-haseitherunicodeflag-abstract-operation' + }, + HasLexicalDeclaration: { + url: 'https://262.ecma-international.org/16.0/#sec-haslexicaldeclaration' + }, + HasOwnProperty: { + url: 'https://262.ecma-international.org/16.0/#sec-hasownproperty' + }, + HasProperty: { + url: 'https://262.ecma-international.org/16.0/#sec-hasproperty' + }, + HasRestrictedGlobalProperty: { + url: 'https://262.ecma-international.org/16.0/#sec-hasrestrictedglobalproperty' + }, + HostEventSet: { + url: 'https://262.ecma-international.org/16.0/#sec-hosteventset' + }, + HourFromTime: { + url: 'https://262.ecma-international.org/16.0/#sec-hourfromtime' + }, + IfAbruptCloseIterator: { + url: 'https://262.ecma-international.org/16.0/#sec-ifabruptcloseiterator' + }, + IfAbruptRejectPromise: { + url: 'https://262.ecma-international.org/16.0/#sec-ifabruptrejectpromise' + }, + ImportedLocalNames: { + url: 'https://262.ecma-international.org/16.0/#sec-importedlocalnames' + }, + IncrementModuleAsyncEvaluationCount: { + url: 'https://262.ecma-international.org/16.0/#sec-IncrementModuleAsyncEvaluationCount' + }, + InitializeBoundName: { + url: 'https://262.ecma-international.org/16.0/#sec-initializeboundname' + }, + InitializeHostDefinedRealm: { + url: 'https://262.ecma-international.org/16.0/#sec-initializehostdefinedrealm' + }, + InitializeInstanceElements: { + url: 'https://262.ecma-international.org/16.0/#sec-initializeinstanceelements' + }, + InitializeReferencedBinding: { + url: 'https://262.ecma-international.org/16.0/#sec-initializereferencedbinding' + }, + InitializeTypedArrayFromArrayBuffer: { + url: 'https://262.ecma-international.org/16.0/#sec-initializetypedarrayfromarraybuffer' + }, + InitializeTypedArrayFromArrayLike: { + url: 'https://262.ecma-international.org/16.0/#sec-initializetypedarrayfromarraylike' + }, + InitializeTypedArrayFromList: { + url: 'https://262.ecma-international.org/16.0/#sec-initializetypedarrayfromlist' + }, + InitializeTypedArrayFromTypedArray: { + url: 'https://262.ecma-international.org/16.0/#sec-initializetypedarrayfromtypedarray' + }, + InLeapYear: { + url: 'https://262.ecma-international.org/16.0/#sec-inleapyear' + }, + InnerModuleEvaluation: { + url: 'https://262.ecma-international.org/16.0/#sec-innermoduleevaluation' + }, + InnerModuleLinking: { + url: 'https://262.ecma-international.org/16.0/#sec-InnerModuleLinking' + }, + InnerModuleLoading: { + url: 'https://262.ecma-international.org/16.0/#sec-InnerModuleLoading' + }, + InstallErrorCause: { + url: 'https://262.ecma-international.org/16.0/#sec-installerrorcause' + }, + InstanceofOperator: { + url: 'https://262.ecma-international.org/16.0/#sec-instanceofoperator' + }, + InternalizeJSONProperty: { + url: 'https://262.ecma-international.org/16.0/#sec-internalizejsonproperty' + }, + Invoke: { + url: 'https://262.ecma-international.org/16.0/#sec-invoke' + }, + IsAccessorDescriptor: { + url: 'https://262.ecma-international.org/16.0/#sec-isaccessordescriptor' + }, + IsAnonymousFunctionDefinition: { + url: 'https://262.ecma-international.org/16.0/#sec-isanonymousfunctiondefinition' + }, + IsArray: { + url: 'https://262.ecma-international.org/16.0/#sec-isarray' + }, + IsArrayBufferViewOutOfBounds: { + url: 'https://262.ecma-international.org/16.0/#sec-isarraybufferviewoutofbounds' + }, + IsBigIntElementType: { + url: 'https://262.ecma-international.org/16.0/#sec-isbigintelementtype' + }, + IsCallable: { + url: 'https://262.ecma-international.org/16.0/#sec-iscallable' + }, + IsCompatiblePropertyDescriptor: { + url: 'https://262.ecma-international.org/16.0/#sec-iscompatiblepropertydescriptor' + }, + IsConcatSpreadable: { + url: 'https://262.ecma-international.org/16.0/#sec-isconcatspreadable' + }, + IsConstructor: { + url: 'https://262.ecma-international.org/16.0/#sec-isconstructor' + }, + IsDataDescriptor: { + url: 'https://262.ecma-international.org/16.0/#sec-isdatadescriptor' + }, + IsDetachedBuffer: { + url: 'https://262.ecma-international.org/16.0/#sec-isdetachedbuffer' + }, + IsExtensible: { + url: 'https://262.ecma-international.org/16.0/#sec-isextensible-o' + }, + IsFixedLengthArrayBuffer: { + url: 'https://262.ecma-international.org/16.0/#sec-isfixedlengtharraybuffer' + }, + IsGenericDescriptor: { + url: 'https://262.ecma-international.org/16.0/#sec-isgenericdescriptor' + }, + IsInTailPosition: { + url: 'https://262.ecma-international.org/16.0/#sec-isintailposition' + }, + IsLabelledFunction: { + url: 'https://262.ecma-international.org/16.0/#sec-islabelledfunction' + }, + IsLessThan: { + url: 'https://262.ecma-international.org/16.0/#sec-islessthan' + }, + IsLooselyEqual: { + url: 'https://262.ecma-international.org/16.0/#sec-islooselyequal' + }, + IsNoTearConfiguration: { + url: 'https://262.ecma-international.org/16.0/#sec-isnotearconfiguration' + }, + IsPrivateReference: { + url: 'https://262.ecma-international.org/16.0/#sec-isprivatereference' + }, + IsPromise: { + url: 'https://262.ecma-international.org/16.0/#sec-ispromise' + }, + IsPropertyReference: { + url: 'https://262.ecma-international.org/16.0/#sec-ispropertyreference' + }, + IsRegExp: { + url: 'https://262.ecma-international.org/16.0/#sec-isregexp' + }, + IsSharedArrayBuffer: { + url: 'https://262.ecma-international.org/16.0/#sec-issharedarraybuffer' + }, + IsStrict: { + url: 'https://262.ecma-international.org/16.0/#sec-isstrict' + }, + IsStrictlyEqual: { + url: 'https://262.ecma-international.org/16.0/#sec-isstrictlyequal' + }, + IsStringWellFormedUnicode: { + url: 'https://262.ecma-international.org/16.0/#sec-isstringwellformedunicode' + }, + IsSuperReference: { + url: 'https://262.ecma-international.org/16.0/#sec-issuperreference' + }, + IsTimeZoneOffsetString: { + url: 'https://262.ecma-international.org/16.0/#sec-istimezoneoffsetstring' + }, + IsTypedArrayFixedLength: { + url: 'https://262.ecma-international.org/16.0/#sec-istypedarrayfixedlength' + }, + IsTypedArrayOutOfBounds: { + url: 'https://262.ecma-international.org/16.0/#sec-istypedarrayoutofbounds' + }, + IsUnclampedIntegerElementType: { + url: 'https://262.ecma-international.org/16.0/#sec-isunclampedintegerelementtype' + }, + IsUnresolvableReference: { + url: 'https://262.ecma-international.org/16.0/#sec-isunresolvablereference' + }, + IsUnsignedElementType: { + url: 'https://262.ecma-international.org/16.0/#sec-isunsignedelementtype' + }, + IsValidIntegerIndex: { + url: 'https://262.ecma-international.org/16.0/#sec-isvalidintegerindex' + }, + IsValidRegularExpressionLiteral: { + url: 'https://262.ecma-international.org/16.0/#sec-isvalidregularexpressionliteral' + }, + IsViewOutOfBounds: { + url: 'https://262.ecma-international.org/16.0/#sec-isviewoutofbounds' + }, + IsWordChar: { + url: 'https://262.ecma-international.org/16.0/#sec-runtime-semantics-iswordchar-abstract-operation' + }, + IteratorClose: { + url: 'https://262.ecma-international.org/16.0/#sec-iteratorclose' + }, + IteratorComplete: { + url: 'https://262.ecma-international.org/16.0/#sec-iteratorcomplete' + }, + IteratorNext: { + url: 'https://262.ecma-international.org/16.0/#sec-iteratornext' + }, + IteratorStep: { + url: 'https://262.ecma-international.org/16.0/#sec-iteratorstep' + }, + IteratorStepValue: { + url: 'https://262.ecma-international.org/16.0/#sec-iteratorstepvalue' + }, + IteratorToList: { + url: 'https://262.ecma-international.org/16.0/#sec-iteratortolist' + }, + IteratorValue: { + url: 'https://262.ecma-international.org/16.0/#sec-iteratorvalue' + }, + KeyForSymbol: { + url: 'https://262.ecma-international.org/16.0/#sec-keyforsymbol' + }, + LeaveCriticalSection: { + url: 'https://262.ecma-international.org/16.0/#sec-leavecriticalsection' + }, + LengthOfArrayLike: { + url: 'https://262.ecma-international.org/16.0/#sec-lengthofarraylike' + }, + LocalTime: { + url: 'https://262.ecma-international.org/16.0/#sec-localtime' + }, + LoopContinues: { + url: 'https://262.ecma-international.org/16.0/#sec-loopcontinues' + }, + MakeArgGetter: { + url: 'https://262.ecma-international.org/16.0/#sec-makearggetter' + }, + MakeArgSetter: { + url: 'https://262.ecma-international.org/16.0/#sec-makeargsetter' + }, + MakeBasicObject: { + url: 'https://262.ecma-international.org/16.0/#sec-makebasicobject' + }, + MakeClassConstructor: { + url: 'https://262.ecma-international.org/16.0/#sec-makeclassconstructor' + }, + MakeConstructor: { + url: 'https://262.ecma-international.org/16.0/#sec-makeconstructor' + }, + MakeDataViewWithBufferWitnessRecord: { + url: 'https://262.ecma-international.org/16.0/#sec-makedataviewwithbufferwitnessrecord' + }, + MakeDate: { + url: 'https://262.ecma-international.org/16.0/#sec-makedate' + }, + MakeDay: { + url: 'https://262.ecma-international.org/16.0/#sec-makeday' + }, + MakeFullYear: { + url: 'https://262.ecma-international.org/16.0/#sec-makefullyear' + }, + MakeMatchIndicesIndexPairArray: { + url: 'https://262.ecma-international.org/16.0/#sec-makematchindicesindexpairarray' + }, + MakeMethod: { + url: 'https://262.ecma-international.org/16.0/#sec-makemethod' + }, + MakePrivateReference: { + url: 'https://262.ecma-international.org/16.0/#sec-makeprivatereference' + }, + MakeSuperPropertyReference: { + url: 'https://262.ecma-international.org/16.0/#sec-makesuperpropertyreference' + }, + MakeTime: { + url: 'https://262.ecma-international.org/16.0/#sec-maketime' + }, + MakeTypedArrayWithBufferWitnessRecord: { + url: 'https://262.ecma-international.org/16.0/#sec-maketypedarraywithbufferwitnessrecord' + }, + MatchSequence: { + url: 'https://262.ecma-international.org/16.0/#sec-matchsequence' + }, + MatchTwoAlternatives: { + url: 'https://262.ecma-international.org/16.0/#sec-matchtwoalternatives' + }, + max: { + url: 'https://262.ecma-international.org/16.0/#eqn-max' + }, + MaybeSimpleCaseFolding: { + url: 'https://262.ecma-international.org/16.0/#sec-maybesimplecasefolding' + }, + MightBothParticipate: { + url: 'https://262.ecma-international.org/16.0/#sec-mightbothparticipate' + }, + min: { + url: 'https://262.ecma-international.org/16.0/#eqn-min' + }, + MinFromTime: { + url: 'https://262.ecma-international.org/16.0/#sec-minfromtime' + }, + ModuleNamespaceCreate: { + url: 'https://262.ecma-international.org/16.0/#sec-modulenamespacecreate' + }, + ModuleRequestsEqual: { + url: 'https://262.ecma-international.org/16.0/#sec-ModuleRequestsEqual' + }, + modulo: { + url: 'https://262.ecma-international.org/16.0/#eqn-modulo' + }, + MonthFromTime: { + url: 'https://262.ecma-international.org/16.0/#sec-monthfromtime' + }, + msFromTime: { + url: 'https://262.ecma-international.org/16.0/#sec-msfromtime' + }, + NewDeclarativeEnvironment: { + url: 'https://262.ecma-international.org/16.0/#sec-newdeclarativeenvironment' + }, + NewFunctionEnvironment: { + url: 'https://262.ecma-international.org/16.0/#sec-newfunctionenvironment' + }, + NewGlobalEnvironment: { + url: 'https://262.ecma-international.org/16.0/#sec-newglobalenvironment' + }, + NewModuleEnvironment: { + url: 'https://262.ecma-international.org/16.0/#sec-newmoduleenvironment' + }, + NewObjectEnvironment: { + url: 'https://262.ecma-international.org/16.0/#sec-newobjectenvironment' + }, + NewPrivateEnvironment: { + url: 'https://262.ecma-international.org/16.0/#sec-newprivateenvironment' + }, + NewPromiseCapability: { + url: 'https://262.ecma-international.org/16.0/#sec-newpromisecapability' + }, + NewPromiseReactionJob: { + url: 'https://262.ecma-international.org/16.0/#sec-newpromisereactionjob' + }, + NewPromiseResolveThenableJob: { + url: 'https://262.ecma-international.org/16.0/#sec-newpromiseresolvethenablejob' + }, + NormalCompletion: { + url: 'https://262.ecma-international.org/16.0/#sec-normalcompletion' + }, + NotifyWaiter: { + url: 'https://262.ecma-international.org/16.0/#sec-notifywaiter' + }, + 'Number::add': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-number-add' + }, + 'Number::bitwiseAND': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-number-bitwiseAND' + }, + 'Number::bitwiseNOT': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-number-bitwiseNOT' + }, + 'Number::bitwiseOR': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-number-bitwiseOR' + }, + 'Number::bitwiseXOR': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-number-bitwiseXOR' + }, + 'Number::divide': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-number-divide' + }, + 'Number::equal': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-number-equal' + }, + 'Number::exponentiate': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-number-exponentiate' + }, + 'Number::leftShift': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-number-leftShift' + }, + 'Number::lessThan': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-number-lessThan' + }, + 'Number::multiply': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-number-multiply' + }, + 'Number::remainder': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-number-remainder' + }, + 'Number::sameValue': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-number-sameValue' + }, + 'Number::sameValueZero': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-number-sameValueZero' + }, + 'Number::signedRightShift': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-number-signedRightShift' + }, + 'Number::subtract': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-number-subtract' + }, + 'Number::toString': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-number-tostring' + }, + 'Number::unaryMinus': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-number-unaryMinus' + }, + 'Number::unsignedRightShift': { + url: 'https://262.ecma-international.org/16.0/#sec-numeric-types-number-unsignedRightShift' + }, + NumberBitwiseOp: { + url: 'https://262.ecma-international.org/16.0/#sec-numberbitwiseop' + }, + NumberToBigInt: { + url: 'https://262.ecma-international.org/16.0/#sec-numbertobigint' + }, + NumericToRawBytes: { + url: 'https://262.ecma-international.org/16.0/#sec-numerictorawbytes' + }, + ObjectDefineProperties: { + url: 'https://262.ecma-international.org/16.0/#sec-objectdefineproperties' + }, + OrdinaryCallBindThis: { + url: 'https://262.ecma-international.org/16.0/#sec-ordinarycallbindthis' + }, + OrdinaryCallEvaluateBody: { + url: 'https://262.ecma-international.org/16.0/#sec-ordinarycallevaluatebody' + }, + OrdinaryCreateFromConstructor: { + url: 'https://262.ecma-international.org/16.0/#sec-ordinarycreatefromconstructor' + }, + OrdinaryDefineOwnProperty: { + url: 'https://262.ecma-international.org/16.0/#sec-ordinarydefineownproperty' + }, + OrdinaryDelete: { + url: 'https://262.ecma-international.org/16.0/#sec-ordinarydelete' + }, + OrdinaryFunctionCreate: { + url: 'https://262.ecma-international.org/16.0/#sec-ordinaryfunctioncreate' + }, + OrdinaryGet: { + url: 'https://262.ecma-international.org/16.0/#sec-ordinaryget' + }, + OrdinaryGetOwnProperty: { + url: 'https://262.ecma-international.org/16.0/#sec-ordinarygetownproperty' + }, + OrdinaryGetPrototypeOf: { + url: 'https://262.ecma-international.org/16.0/#sec-ordinarygetprototypeof' + }, + OrdinaryHasInstance: { + url: 'https://262.ecma-international.org/16.0/#sec-ordinaryhasinstance' + }, + OrdinaryHasProperty: { + url: 'https://262.ecma-international.org/16.0/#sec-ordinaryhasproperty' + }, + OrdinaryIsExtensible: { + url: 'https://262.ecma-international.org/16.0/#sec-ordinaryisextensible' + }, + OrdinaryObjectCreate: { + url: 'https://262.ecma-international.org/16.0/#sec-ordinaryobjectcreate' + }, + OrdinaryOwnPropertyKeys: { + url: 'https://262.ecma-international.org/16.0/#sec-ordinaryownpropertykeys' + }, + OrdinaryPreventExtensions: { + url: 'https://262.ecma-international.org/16.0/#sec-ordinarypreventextensions' + }, + OrdinarySet: { + url: 'https://262.ecma-international.org/16.0/#sec-ordinaryset' + }, + OrdinarySetPrototypeOf: { + url: 'https://262.ecma-international.org/16.0/#sec-ordinarysetprototypeof' + }, + OrdinarySetWithOwnDescriptor: { + url: 'https://262.ecma-international.org/16.0/#sec-ordinarysetwithowndescriptor' + }, + OrdinaryToPrimitive: { + url: 'https://262.ecma-international.org/16.0/#sec-ordinarytoprimitive' + }, + ParseHexOctet: { + url: 'https://262.ecma-international.org/16.0/#sec-parsehexoctet' + }, + ParseJSON: { + url: 'https://262.ecma-international.org/16.0/#sec-ParseJSON' + }, + ParseJSONModule: { + url: 'https://262.ecma-international.org/16.0/#sec-parse-json-module' + }, + ParseModule: { + url: 'https://262.ecma-international.org/16.0/#sec-parsemodule' + }, + ParsePattern: { + url: 'https://262.ecma-international.org/16.0/#sec-parsepattern' + }, + ParseScript: { + url: 'https://262.ecma-international.org/16.0/#sec-parse-script' + }, + ParseText: { + url: 'https://262.ecma-international.org/16.0/#sec-parsetext' + }, + ParseTimeZoneOffsetString: { + url: 'https://262.ecma-international.org/16.0/#sec-parsetimezoneoffsetstring' + }, + PerformEval: { + url: 'https://262.ecma-international.org/16.0/#sec-performeval' + }, + PerformPromiseAll: { + url: 'https://262.ecma-international.org/16.0/#sec-performpromiseall' + }, + PerformPromiseAllSettled: { + url: 'https://262.ecma-international.org/16.0/#sec-performpromiseallsettled' + }, + PerformPromiseAny: { + url: 'https://262.ecma-international.org/16.0/#sec-performpromiseany' + }, + PerformPromiseRace: { + url: 'https://262.ecma-international.org/16.0/#sec-performpromiserace' + }, + PerformPromiseThen: { + url: 'https://262.ecma-international.org/16.0/#sec-performpromisethen' + }, + PrepareForOrdinaryCall: { + url: 'https://262.ecma-international.org/16.0/#sec-prepareforordinarycall' + }, + PrepareForTailCall: { + url: 'https://262.ecma-international.org/16.0/#sec-preparefortailcall' + }, + PrivateElementFind: { + url: 'https://262.ecma-international.org/16.0/#sec-privateelementfind' + }, + PrivateFieldAdd: { + url: 'https://262.ecma-international.org/16.0/#sec-privatefieldadd' + }, + PrivateGet: { + url: 'https://262.ecma-international.org/16.0/#sec-privateget' + }, + PrivateMethodOrAccessorAdd: { + url: 'https://262.ecma-international.org/16.0/#sec-privatemethodoraccessoradd' + }, + PrivateSet: { + url: 'https://262.ecma-international.org/16.0/#sec-privateset' + }, + PromiseResolve: { + url: 'https://262.ecma-international.org/16.0/#sec-promise-resolve' + }, + ProxyCreate: { + url: 'https://262.ecma-international.org/16.0/#sec-proxycreate' + }, + PutValue: { + url: 'https://262.ecma-international.org/16.0/#sec-putvalue' + }, + QuoteJSONString: { + url: 'https://262.ecma-international.org/16.0/#sec-quotejsonstring' + }, + ℝ: { + url: 'https://262.ecma-international.org/16.0/#ℝ' + }, + RawBytesToNumeric: { + url: 'https://262.ecma-international.org/16.0/#sec-rawbytestonumeric' + }, + 'reads-bytes-from': { + url: 'https://262.ecma-international.org/16.0/#sec-reads-bytes-from' + }, + RegExpAlloc: { + url: 'https://262.ecma-international.org/16.0/#sec-regexpalloc' + }, + RegExpBuiltinExec: { + url: 'https://262.ecma-international.org/16.0/#sec-regexpbuiltinexec' + }, + RegExpCreate: { + url: 'https://262.ecma-international.org/16.0/#sec-regexpcreate' + }, + RegExpExec: { + url: 'https://262.ecma-international.org/16.0/#sec-regexpexec' + }, + RegExpHasFlag: { + url: 'https://262.ecma-international.org/16.0/#sec-regexphasflag' + }, + RegExpInitialize: { + url: 'https://262.ecma-international.org/16.0/#sec-regexpinitialize' + }, + RejectPromise: { + url: 'https://262.ecma-international.org/16.0/#sec-rejectpromise' + }, + RemoveWaiter: { + url: 'https://262.ecma-international.org/16.0/#sec-removewaiter' + }, + RemoveWaiters: { + url: 'https://262.ecma-international.org/16.0/#sec-removewaiters' + }, + RepeatMatcher: { + url: 'https://262.ecma-international.org/16.0/#sec-runtime-semantics-repeatmatcher-abstract-operation' + }, + RequireInternalSlot: { + url: 'https://262.ecma-international.org/16.0/#sec-requireinternalslot' + }, + RequireObjectCoercible: { + url: 'https://262.ecma-international.org/16.0/#sec-requireobjectcoercible' + }, + ResolveBinding: { + url: 'https://262.ecma-international.org/16.0/#sec-resolvebinding' + }, + ResolvePrivateIdentifier: { + url: 'https://262.ecma-international.org/16.0/#sec-resolve-private-identifier' + }, + ResolveThisBinding: { + url: 'https://262.ecma-international.org/16.0/#sec-resolvethisbinding' + }, + ReturnCompletion: { + url: 'https://262.ecma-international.org/16.0/#sec-returncompletion' + }, + ReturnIfAbrupt: { + url: 'https://262.ecma-international.org/16.0/#sec-returnifabrupt' + }, + RevalidateAtomicAccess: { + url: 'https://262.ecma-international.org/16.0/#sec-revalidateatomicaccess' + }, + RoundMVResult: { + url: 'https://262.ecma-international.org/16.0/#sec-roundmvresult' + }, + SameType: { + url: 'https://262.ecma-international.org/16.0/#sec-sametype' + }, + SameValue: { + url: 'https://262.ecma-international.org/16.0/#sec-samevalue' + }, + SameValueNonNumber: { + url: 'https://262.ecma-international.org/16.0/#sec-samevaluenonnumber' + }, + SameValueZero: { + url: 'https://262.ecma-international.org/16.0/#sec-samevaluezero' + }, + scf: { + url: 'https://262.ecma-international.org/16.0/#eqn-scf' + }, + ScriptEvaluation: { + url: 'https://262.ecma-international.org/16.0/#sec-runtime-semantics-scriptevaluation' + }, + SecFromTime: { + url: 'https://262.ecma-international.org/16.0/#sec-secfromtime' + }, + SerializeJSONArray: { + url: 'https://262.ecma-international.org/16.0/#sec-serializejsonarray' + }, + SerializeJSONObject: { + url: 'https://262.ecma-international.org/16.0/#sec-serializejsonobject' + }, + SerializeJSONProperty: { + url: 'https://262.ecma-international.org/16.0/#sec-serializejsonproperty' + }, + Set: { + url: 'https://262.ecma-international.org/16.0/#sec-set-o-p-v-throw' + }, + SetDataHas: { + url: 'https://262.ecma-international.org/16.0/#sec-setdatahas' + }, + SetDataIndex: { + url: 'https://262.ecma-international.org/16.0/#sec-setdataindex' + }, + SetDataSize: { + url: 'https://262.ecma-international.org/16.0/#sec-setdatasize' + }, + SetDefaultGlobalBindings: { + url: 'https://262.ecma-international.org/16.0/#sec-setdefaultglobalbindings' + }, + SetFunctionLength: { + url: 'https://262.ecma-international.org/16.0/#sec-setfunctionlength' + }, + SetFunctionName: { + url: 'https://262.ecma-international.org/16.0/#sec-setfunctionname' + }, + SetImmutablePrototype: { + url: 'https://262.ecma-international.org/16.0/#sec-set-immutable-prototype' + }, + SetIntegrityLevel: { + url: 'https://262.ecma-international.org/16.0/#sec-setintegritylevel' + }, + SetSyntheticModuleExport: { + url: 'https://262.ecma-international.org/16.0/#sec-setsyntheticmoduleexport' + }, + SetterThatIgnoresPrototypeProperties: { + url: 'https://262.ecma-international.org/16.0/#sec-SetterThatIgnoresPrototypeProperties' + }, + SetTypedArrayFromArrayLike: { + url: 'https://262.ecma-international.org/16.0/#sec-settypedarrayfromarraylike' + }, + SetTypedArrayFromTypedArray: { + url: 'https://262.ecma-international.org/16.0/#sec-settypedarrayfromtypedarray' + }, + SetValueInBuffer: { + url: 'https://262.ecma-international.org/16.0/#sec-setvalueinbuffer' + }, + SetViewValue: { + url: 'https://262.ecma-international.org/16.0/#sec-setviewvalue' + }, + SharedDataBlockEventSet: { + url: 'https://262.ecma-international.org/16.0/#sec-sharedatablockeventset' + }, + SortIndexedProperties: { + url: 'https://262.ecma-international.org/16.0/#sec-sortindexedproperties' + }, + SpeciesConstructor: { + url: 'https://262.ecma-international.org/16.0/#sec-speciesconstructor' + }, + StringCreate: { + url: 'https://262.ecma-international.org/16.0/#sec-stringcreate' + }, + StringGetOwnProperty: { + url: 'https://262.ecma-international.org/16.0/#sec-stringgetownproperty' + }, + StringIndexOf: { + url: 'https://262.ecma-international.org/16.0/#sec-stringindexof' + }, + StringLastIndexOf: { + url: 'https://262.ecma-international.org/16.0/#sec-stringlastindexof' + }, + StringPad: { + url: 'https://262.ecma-international.org/16.0/#sec-stringpad' + }, + StringPaddingBuiltinsImpl: { + url: 'https://262.ecma-international.org/16.0/#sec-stringpaddingbuiltinsimpl' + }, + StringToBigInt: { + url: 'https://262.ecma-international.org/16.0/#sec-stringtobigint' + }, + StringToCodePoints: { + url: 'https://262.ecma-international.org/16.0/#sec-stringtocodepoints' + }, + StringToNumber: { + url: 'https://262.ecma-international.org/16.0/#sec-stringtonumber' + }, + substring: { + url: 'https://262.ecma-international.org/16.0/#substring' + }, + SuspendThisAgent: { + url: 'https://262.ecma-international.org/16.0/#sec-suspendthisagent' + }, + SymbolDescriptiveString: { + url: 'https://262.ecma-international.org/16.0/#sec-symboldescriptivestring' + }, + SystemTimeZoneIdentifier: { + url: 'https://262.ecma-international.org/16.0/#sec-systemtimezoneidentifier' + }, + TemplateString: { + url: 'https://262.ecma-international.org/16.0/#sec-templatestring' + }, + TestIntegrityLevel: { + url: 'https://262.ecma-international.org/16.0/#sec-testintegritylevel' + }, + ThisBigIntValue: { + url: 'https://262.ecma-international.org/16.0/#sec-thisbigintvalue' + }, + ThisBooleanValue: { + url: 'https://262.ecma-international.org/16.0/#sec-thisbooleanvalue' + }, + ThisNumberValue: { + url: 'https://262.ecma-international.org/16.0/#sec-thisnumbervalue' + }, + ThisStringValue: { + url: 'https://262.ecma-international.org/16.0/#sec-thisstringvalue' + }, + ThisSymbolValue: { + url: 'https://262.ecma-international.org/16.0/#sec-thissymbolvalue' + }, + ThrowCompletion: { + url: 'https://262.ecma-international.org/16.0/#sec-throwcompletion' + }, + TimeClip: { + url: 'https://262.ecma-international.org/16.0/#sec-timeclip' + }, + TimeFromYear: { + url: 'https://262.ecma-international.org/16.0/#sec-timefromyear' + }, + TimeString: { + url: 'https://262.ecma-international.org/16.0/#sec-timestring' + }, + TimeWithinDay: { + url: 'https://262.ecma-international.org/16.0/#sec-timewithinday' + }, + TimeZoneString: { + url: 'https://262.ecma-international.org/16.0/#sec-timezoneestring' + }, + ToBigInt: { + url: 'https://262.ecma-international.org/16.0/#sec-tobigint' + }, + ToBigInt64: { + url: 'https://262.ecma-international.org/16.0/#sec-tobigint64' + }, + ToBigUint64: { + url: 'https://262.ecma-international.org/16.0/#sec-tobiguint64' + }, + ToBoolean: { + url: 'https://262.ecma-international.org/16.0/#sec-toboolean' + }, + ToDateString: { + url: 'https://262.ecma-international.org/16.0/#sec-todatestring' + }, + ToIndex: { + url: 'https://262.ecma-international.org/16.0/#sec-toindex' + }, + ToInt16: { + url: 'https://262.ecma-international.org/16.0/#sec-toint16' + }, + ToInt32: { + url: 'https://262.ecma-international.org/16.0/#sec-toint32' + }, + ToInt8: { + url: 'https://262.ecma-international.org/16.0/#sec-toint8' + }, + ToIntegerOrInfinity: { + url: 'https://262.ecma-international.org/16.0/#sec-tointegerorinfinity' + }, + ToLength: { + url: 'https://262.ecma-international.org/16.0/#sec-tolength' + }, + ToNumber: { + url: 'https://262.ecma-international.org/16.0/#sec-tonumber' + }, + ToNumeric: { + url: 'https://262.ecma-international.org/16.0/#sec-tonumeric' + }, + ToObject: { + url: 'https://262.ecma-international.org/16.0/#sec-toobject' + }, + ToPrimitive: { + url: 'https://262.ecma-international.org/16.0/#sec-toprimitive' + }, + ToPropertyDescriptor: { + url: 'https://262.ecma-international.org/16.0/#sec-topropertydescriptor' + }, + ToPropertyKey: { + url: 'https://262.ecma-international.org/16.0/#sec-topropertykey' + }, + ToString: { + url: 'https://262.ecma-international.org/16.0/#sec-tostring' + }, + ToUint16: { + url: 'https://262.ecma-international.org/16.0/#sec-touint16' + }, + ToUint32: { + url: 'https://262.ecma-international.org/16.0/#sec-touint32' + }, + ToUint8: { + url: 'https://262.ecma-international.org/16.0/#sec-touint8' + }, + ToUint8Clamp: { + url: 'https://262.ecma-international.org/16.0/#sec-touint8clamp' + }, + ToZeroPaddedDecimalString: { + url: 'https://262.ecma-international.org/16.0/#sec-tozeropaddeddecimalstring' + }, + TriggerPromiseReactions: { + url: 'https://262.ecma-international.org/16.0/#sec-triggerpromisereactions' + }, + TrimString: { + url: 'https://262.ecma-international.org/16.0/#sec-trimstring' + }, + truncate: { + url: 'https://262.ecma-international.org/16.0/#eqn-truncate' + }, + TypedArrayByteLength: { + url: 'https://262.ecma-international.org/16.0/#sec-typedarraybytelength' + }, + TypedArrayCreate: { + url: 'https://262.ecma-international.org/16.0/#sec-typedarraycreate' + }, + TypedArrayCreateFromConstructor: { + url: 'https://262.ecma-international.org/16.0/#sec-typedarraycreatefromconstructor' + }, + TypedArrayCreateSameType: { + url: 'https://262.ecma-international.org/16.0/#sec-typedarray-create-same-type' + }, + TypedArrayElementSize: { + url: 'https://262.ecma-international.org/16.0/#sec-typedarrayelementsize' + }, + TypedArrayElementType: { + url: 'https://262.ecma-international.org/16.0/#sec-typedarrayelementtype' + }, + TypedArrayGetElement: { + url: 'https://262.ecma-international.org/16.0/#sec-typedarraygetelement' + }, + TypedArrayLength: { + url: 'https://262.ecma-international.org/16.0/#sec-typedarraylength' + }, + TypedArraySetElement: { + url: 'https://262.ecma-international.org/16.0/#sec-typedarraysetelement' + }, + TypedArraySpeciesCreate: { + url: 'https://262.ecma-international.org/16.0/#typedarray-species-create' + }, + UnicodeEscape: { + url: 'https://262.ecma-international.org/16.0/#sec-unicodeescape' + }, + UnicodeMatchProperty: { + url: 'https://262.ecma-international.org/16.0/#sec-runtime-semantics-unicodematchproperty-p' + }, + UnicodeMatchPropertyValue: { + url: 'https://262.ecma-international.org/16.0/#sec-runtime-semantics-unicodematchpropertyvalue-p-v' + }, + UpdateEmpty: { + url: 'https://262.ecma-international.org/16.0/#sec-updateempty' + }, + UpdateModifiers: { + url: 'https://262.ecma-international.org/16.0/#sec-updatemodifiers' + }, + UTC: { + url: 'https://262.ecma-international.org/16.0/#sec-utc-t' + }, + UTF16EncodeCodePoint: { + url: 'https://262.ecma-international.org/16.0/#sec-utf16encodecodepoint' + }, + UTF16SurrogatePairToCodePoint: { + url: 'https://262.ecma-international.org/16.0/#sec-utf16decodesurrogatepair' + }, + ValidateAndApplyPropertyDescriptor: { + url: 'https://262.ecma-international.org/16.0/#sec-validateandapplypropertydescriptor' + }, + ValidateAtomicAccess: { + url: 'https://262.ecma-international.org/16.0/#sec-validateatomicaccess' + }, + ValidateAtomicAccessOnIntegerTypedArray: { + url: 'https://262.ecma-international.org/16.0/#sec-validateatomicaccessonintegertypedarray' + }, + ValidateIntegerTypedArray: { + url: 'https://262.ecma-international.org/16.0/#sec-validateintegertypedarray' + }, + ValidateNonRevokedProxy: { + url: 'https://262.ecma-international.org/16.0/#sec-validatenonrevokedproxy' + }, + ValidateTypedArray: { + url: 'https://262.ecma-international.org/16.0/#sec-validatetypedarray' + }, + ValueOfReadEvent: { + url: 'https://262.ecma-international.org/16.0/#sec-valueofreadevent' + }, + WeakRefDeref: { + url: 'https://262.ecma-international.org/16.0/#sec-weakrefderef' + }, + WeekDay: { + url: 'https://262.ecma-international.org/16.0/#sec-weekday' + }, + WordCharacters: { + url: 'https://262.ecma-international.org/16.0/#sec-wordcharacters' + }, + YearFromTime: { + url: 'https://262.ecma-international.org/16.0/#sec-yearfromtime' + }, + Yield: { + url: 'https://262.ecma-international.org/16.0/#sec-yield' + }, + ℤ: { + url: 'https://262.ecma-international.org/16.0/#ℤ' + } +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/es5.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/es5.js new file mode 100644 index 0000000000000000000000000000000000000000..614a1ddf3d23ba3c665745ee926793a5289755c2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/operations/es5.js @@ -0,0 +1,50 @@ +'use strict'; + +module.exports = { + 'Abstract Equality Comparison': 'https://262.ecma-international.org/5.1/#sec-11.9.3', + 'Abstract Relational Comparison': 'https://262.ecma-international.org/5.1/#sec-11.8.5', + 'Strict Equality Comparison': 'https://262.ecma-international.org/5.1/#sec-11.9.6', + abs: 'http://262.ecma-international.org/5.1/#sec-5.2', + Canonicalize: 'https://262.ecma-international.org/5.1/#sec-15.10.2.8', + CheckObjectCoercible: 'https://262.ecma-international.org/5.1/#sec-9.10', + DateFromTime: 'https://262.ecma-international.org/5.1/#sec-15.9.1.5', + Day: 'https://262.ecma-international.org/5.1/#sec-15.9.1.2', + DayFromYear: 'https://262.ecma-international.org/5.1/#sec-15.9.1.3', + DaysInYear: 'https://262.ecma-international.org/5.1/#sec-15.9.1.3', + DayWithinYear: 'https://262.ecma-international.org/5.1/#sec-15.9.1.4', + floor: 'http://262.ecma-international.org/5.1/#sec-5.2', + FromPropertyDescriptor: 'https://262.ecma-international.org/5.1/#sec-8.10.4', + HourFromTime: 'https://262.ecma-international.org/5.1/#sec-15.9.1.10', + InLeapYear: 'https://262.ecma-international.org/5.1/#sec-15.9.1.3', + IsAccessorDescriptor: 'https://262.ecma-international.org/5.1/#sec-8.10.1', + IsCallable: 'https://262.ecma-international.org/5.1/#sec-9.11', + IsDataDescriptor: 'https://262.ecma-international.org/5.1/#sec-8.10.2', + IsGenericDescriptor: 'https://262.ecma-international.org/5.1/#sec-8.10.3', + IsPropertyDescriptor: 'https://262.ecma-international.org/5.1/#sec-8.10', + MakeDate: 'https://262.ecma-international.org/5.1/#sec-15.9.1.13', + MakeDay: 'https://262.ecma-international.org/5.1/#sec-15.9.1.12', + MakeTime: 'https://262.ecma-international.org/5.1/#sec-15.9.1.11', + MinFromTime: 'https://262.ecma-international.org/5.1/#sec-15.9.1.10', + modulo: 'https://262.ecma-international.org/5.1/#sec-5.2', + MonthFromTime: 'https://262.ecma-international.org/5.1/#sec-15.9.1.4', + msFromTime: 'https://262.ecma-international.org/5.1/#sec-15.9.1.10', + SameValue: 'https://262.ecma-international.org/5.1/#sec-9.12', + SecFromTime: 'https://262.ecma-international.org/5.1/#sec-15.9.1.10', + SplitMatch: 'https://262.ecma-international.org/5.1/#sec-15.5.4.14', + TimeClip: 'https://262.ecma-international.org/5.1/#sec-15.9.1.14', + TimeFromYear: 'https://262.ecma-international.org/5.1/#sec-15.9.1.3', + TimeWithinDay: 'https://262.ecma-international.org/5.1/#sec-15.9.1.2', + ToBoolean: 'https://262.ecma-international.org/5.1/#sec-9.2', + ToInt32: 'https://262.ecma-international.org/5.1/#sec-9.5', + ToInteger: 'https://262.ecma-international.org/5.1/#sec-9.4', + ToNumber: 'https://262.ecma-international.org/5.1/#sec-9.3', + ToObject: 'https://262.ecma-international.org/5.1/#sec-9.9', + ToPrimitive: 'https://262.ecma-international.org/5.1/#sec-9.1', + ToPropertyDescriptor: 'https://262.ecma-international.org/5.1/#sec-8.10.5', + ToString: 'https://262.ecma-international.org/5.1/#sec-9.8', + ToUint16: 'https://262.ecma-international.org/5.1/#sec-9.7', + ToUint32: 'https://262.ecma-international.org/5.1/#sec-9.6', + Type: 'https://262.ecma-international.org/5.1/#sec-8', + WeekDay: 'https://262.ecma-international.org/5.1/#sec-15.9.1.6', + YearFromTime: 'https://262.ecma-international.org/5.1/#sec-15.9.1.3' +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-errors/.github/FUNDING.yml b/novas/novacore-zephyr/groq-code-cli/node_modules/es-errors/.github/FUNDING.yml new file mode 100644 index 0000000000000000000000000000000000000000..f1b880554aae3ac981c255f24b8a38ff7bed627e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-errors/.github/FUNDING.yml @@ -0,0 +1,12 @@ +# These are supported funding model platforms + +github: [ljharb] +patreon: # Replace with a single Patreon username +open_collective: # Replace with a single Open Collective username +ko_fi: # Replace with a single Ko-fi username +tidelift: npm/es-errors +community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry +liberapay: # Replace with a single Liberapay username +issuehunt: # Replace with a single IssueHunt username +otechie: # Replace with a single Otechie username +custom: # Replace with a single custom sponsorship URL diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-errors/test/index.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-errors/test/index.js new file mode 100644 index 0000000000000000000000000000000000000000..1ff027721aabcada7c00b9e69fbd6f99a901c470 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-errors/test/index.js @@ -0,0 +1,19 @@ +'use strict'; + +var test = require('tape'); + +var E = require('../'); +var R = require('../range'); +var Ref = require('../ref'); +var S = require('../syntax'); +var T = require('../type'); + +test('errors', function (t) { + t.equal(E, Error); + t.equal(R, RangeError); + t.equal(Ref, ReferenceError); + t.equal(S, SyntaxError); + t.equal(T, TypeError); + + t.end(); +}); diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/find-up/index.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/find-up/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..64f40490e5fe9d3453f5b2158a908bea7c7df0a8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/find-up/index.d.ts @@ -0,0 +1,248 @@ +/* eslint-disable @typescript-eslint/unified-signatures */ +import {Options as LocatePathOptions} from 'locate-path'; + +/** +Return this in a `matcher` function to stop the search and force `findUp` to immediately return `undefined`. +*/ +export const findUpStop: unique symbol; + +export type Match = string | typeof findUpStop | undefined; + +export interface Options extends LocatePathOptions { + /** + The path to the directory to stop the search before reaching root if there were no matches before the `stopAt` directory. + + @default path.parse(cwd).root + */ + readonly stopAt?: string; +} + +/** +Find a file or directory by walking up parent directories. + +@param name - The name of the file or directory to find. Can be multiple. +@returns The first path found (by respecting the order of `name`s) or `undefined` if none could be found. + +@example +``` +// / +// └── Users +// └── sindresorhus +// ├── unicorn.png +// └── foo +// └── bar +// ├── baz +// └── example.js + +// example.js +import {findUp} from 'find-up'; + +console.log(await findUp('unicorn.png')); +//=> '/Users/sindresorhus/unicorn.png' + +console.log(await findUp(['rainbow.png', 'unicorn.png'])); +//=> '/Users/sindresorhus/unicorn.png' +``` +*/ +export function findUp(name: string | readonly string[], options?: Options): Promise; + +/** +Find a file or directory by walking up parent directories. + +@param matcher - Called for each directory in the search. Return a path or `findUpStop` to stop the search. +@returns The first path found or `undefined` if none could be found. + +@example +``` +import path from 'node:path'; +import {findUp, pathExists} from 'find-up'; + +console.log(await findUp(async directory => { + const hasUnicorns = await pathExists(path.join(directory, 'unicorn.png')); + return hasUnicorns && directory; +}, {type: 'directory'})); +//=> '/Users/sindresorhus' +``` +*/ +export function findUp(matcher: (directory: string) => (Match | Promise), options?: Options): Promise; + +/** +Synchronously find a file or directory by walking up parent directories. + +@param name - The name of the file or directory to find. Can be multiple. +@returns The first path found (by respecting the order of `name`s) or `undefined` if none could be found. + +@example +``` +// / +// └── Users +// └── sindresorhus +// ├── unicorn.png +// └── foo +// └── bar +// ├── baz +// └── example.js + +// example.js +import {findUpSync} from 'find-up'; + +console.log(findUpSync('unicorn.png')); +//=> '/Users/sindresorhus/unicorn.png' + +console.log(findUpSync(['rainbow.png', 'unicorn.png'])); +//=> '/Users/sindresorhus/unicorn.png' +``` +*/ +export function findUpSync(name: string | readonly string[], options?: Options): string | undefined; + +/** +Synchronously find a file or directory by walking up parent directories. + +@param matcher - Called for each directory in the search. Return a path or `findUpStop` to stop the search. +@returns The first path found or `undefined` if none could be found. + +@example +``` +import path from 'node:path'; +import {findUpSync, pathExistsSync} from 'find-up'; + +console.log(findUpSync(directory => { + const hasUnicorns = pathExistsSync(path.join(directory, 'unicorn.png')); + return hasUnicorns && directory; +}, {type: 'directory'})); +//=> '/Users/sindresorhus' +``` +*/ +export function findUpSync(matcher: (directory: string) => Match, options?: Options): string | undefined; + +/** +Find files or directories by walking up parent directories. + +@param name - The name of the file or directory to find. Can be multiple. +@returns All paths found (by respecting the order of `name`s) or an empty array if none could be found. + +@example +``` +// / +// └── Users +// └── sindresorhus +// ├── unicorn.png +// └── foo +// ├── unicorn.png +// └── bar +// ├── baz +// └── example.js + +// example.js +import {findUpMultiple} from 'find-up'; + +console.log(await findUpMultiple('unicorn.png')); +//=> ['/Users/sindresorhus/foo/unicorn.png', '/Users/sindresorhus/unicorn.png'] + +console.log(await findUpMultiple(['rainbow.png', 'unicorn.png'])); +//=> ['/Users/sindresorhus/foo/unicorn.png', '/Users/sindresorhus/unicorn.png'] +``` +*/ +export function findUpMultiple(name: string | readonly string[], options?: Options): Promise; + +/** +Find files or directories by walking up parent directories. + +@param matcher - Called for each directory in the search. Return a path or `findUpStop` to stop the search. +@returns All paths found or an empty array if none could be found. + +@example +``` +import path from 'node:path'; +import {findUpMultiple, pathExists} from 'find-up'; + +console.log(await findUpMultiple(async directory => { + const hasUnicorns = await pathExists(path.join(directory, 'unicorn.png')); + return hasUnicorns && directory; +}, {type: 'directory'})); +//=> ['/Users/sindresorhus/foo', '/Users/sindresorhus'] +``` +*/ +export function findUpMultiple(matcher: (directory: string) => (Match | Promise), options?: Options): Promise; + +/** +Synchronously find files or directories by walking up parent directories. + +@param name - The name of the file or directory to find. Can be multiple. +@returns All paths found (by respecting the order of `name`s) or an empty array if none could be found. + +@example +``` +// / +// └── Users +// └── sindresorhus +// ├── unicorn.png +// └── foo +// ├── unicorn.png +// └── bar +// ├── baz +// └── example.js + +// example.js +import {findUpMultipleSync} from 'find-up'; + +console.log(findUpMultipleSync('unicorn.png')); +//=> ['/Users/sindresorhus/foo/unicorn.png', '/Users/sindresorhus/unicorn.png'] + +console.log(findUpMultipleSync(['rainbow.png', 'unicorn.png'])); +//=> ['/Users/sindresorhus/foo/unicorn.png', '/Users/sindresorhus/unicorn.png'] +``` +*/ +export function findUpMultipleSync(name: string | readonly string[], options?: Options): string[]; + +/** +Synchronously find files or directories by walking up parent directories. + +@param matcher - Called for each directory in the search. Return a path or `findUpStop` to stop the search. +@returns All paths found or an empty array if none could be found. + +@example +``` +import path from 'node:path'; +import {findUpMultipleSync, pathExistsSync} from 'find-up'; + +console.log(findUpMultipleSync(directory => { + const hasUnicorns = pathExistsSync(path.join(directory, 'unicorn.png')); + return hasUnicorns && directory; +}, {type: 'directory'})); +//=> ['/Users/sindresorhus/foo', '/Users/sindresorhus'] +``` +*/ +export function findUpMultipleSync(matcher: (directory: string) => Match, options?: Options): string[]; + +/** +Check if a path exists. + +@param path - The path to a file or directory. +@returns Whether the path exists. + +@example +``` +import {pathExists} from 'find-up'; + +console.log(await pathExists('/Users/sindresorhus/unicorn.png')); +//=> true +``` +*/ +export function pathExists(path: string): Promise; + +/** +Synchronously check if a path exists. + +@param path - Path to the file or directory. +@returns Whether the path exists. + +@example +``` +import {pathExistsSync} from 'find-up'; + +console.log(pathExistsSync('/Users/sindresorhus/unicorn.png')); +//=> true +``` +*/ +export function pathExistsSync(path: string): boolean; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/find-up/index.js b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/find-up/index.js new file mode 100644 index 0000000000000000000000000000000000000000..647a1ceb17bbc55b6f6a9d840dc75a0282586007 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/find-up/index.js @@ -0,0 +1,109 @@ +import path from 'node:path'; +import {fileURLToPath} from 'node:url'; +import {locatePath, locatePathSync} from 'locate-path'; + +const toPath = urlOrPath => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath; + +export const findUpStop = Symbol('findUpStop'); + +export async function findUpMultiple(name, options = {}) { + let directory = path.resolve(toPath(options.cwd) || ''); + const {root} = path.parse(directory); + const stopAt = path.resolve(directory, options.stopAt || root); + const limit = options.limit || Number.POSITIVE_INFINITY; + const paths = [name].flat(); + + const runMatcher = async locateOptions => { + if (typeof name !== 'function') { + return locatePath(paths, locateOptions); + } + + const foundPath = await name(locateOptions.cwd); + if (typeof foundPath === 'string') { + return locatePath([foundPath], locateOptions); + } + + return foundPath; + }; + + const matches = []; + // eslint-disable-next-line no-constant-condition + while (true) { + // eslint-disable-next-line no-await-in-loop + const foundPath = await runMatcher({...options, cwd: directory}); + + if (foundPath === findUpStop) { + break; + } + + if (foundPath) { + matches.push(path.resolve(directory, foundPath)); + } + + if (directory === stopAt || matches.length >= limit) { + break; + } + + directory = path.dirname(directory); + } + + return matches; +} + +export function findUpMultipleSync(name, options = {}) { + let directory = path.resolve(toPath(options.cwd) || ''); + const {root} = path.parse(directory); + const stopAt = options.stopAt || root; + const limit = options.limit || Number.POSITIVE_INFINITY; + const paths = [name].flat(); + + const runMatcher = locateOptions => { + if (typeof name !== 'function') { + return locatePathSync(paths, locateOptions); + } + + const foundPath = name(locateOptions.cwd); + if (typeof foundPath === 'string') { + return locatePathSync([foundPath], locateOptions); + } + + return foundPath; + }; + + const matches = []; + // eslint-disable-next-line no-constant-condition + while (true) { + const foundPath = runMatcher({...options, cwd: directory}); + + if (foundPath === findUpStop) { + break; + } + + if (foundPath) { + matches.push(path.resolve(directory, foundPath)); + } + + if (directory === stopAt || matches.length >= limit) { + break; + } + + directory = path.dirname(directory); + } + + return matches; +} + +export async function findUp(name, options = {}) { + const matches = await findUpMultiple(name, {...options, limit: 1}); + return matches[0]; +} + +export function findUpSync(name, options = {}) { + const matches = findUpMultipleSync(name, {...options, limit: 1}); + return matches[0]; +} + +export { + pathExists, + pathExistsSync, +} from 'path-exists'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/find-up/license b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/find-up/license new file mode 100644 index 0000000000000000000000000000000000000000..fa7ceba3eb4a9657a9db7f3ffca4e4e97a9019de --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/find-up/license @@ -0,0 +1,9 @@ +MIT License + +Copyright (c) Sindre Sorhus (https://sindresorhus.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. diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/find-up/package.json b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/find-up/package.json new file mode 100644 index 0000000000000000000000000000000000000000..23cb409da67434873fa723929a977784cfb13894 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/find-up/package.json @@ -0,0 +1,56 @@ +{ + "name": "find-up", + "version": "6.3.0", + "description": "Find a file or directory by walking up parent directories", + "license": "MIT", + "repository": "sindresorhus/find-up", + "funding": "https://github.com/sponsors/sindresorhus", + "author": { + "name": "Sindre Sorhus", + "email": "sindresorhus@gmail.com", + "url": "https://sindresorhus.com" + }, + "type": "module", + "exports": "./index.js", + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "scripts": { + "test": "xo && ava && tsd" + }, + "files": [ + "index.js", + "index.d.ts" + ], + "keywords": [ + "find", + "up", + "find-up", + "findup", + "look-up", + "look", + "file", + "search", + "match", + "package", + "resolve", + "parent", + "parents", + "folder", + "directory", + "walk", + "walking", + "path" + ], + "dependencies": { + "locate-path": "^7.1.0", + "path-exists": "^5.0.0" + }, + "devDependencies": { + "ava": "^3.15.0", + "is-path-inside": "^4.0.0", + "tempy": "^2.0.0", + "tsd": "^0.17.0", + "xo": "^0.44.0" + } +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/find-up/readme.md b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/find-up/readme.md new file mode 100644 index 0000000000000000000000000000000000000000..488ac618396e268fc6032d4b197ba4a2f0cb4dee --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/find-up/readme.md @@ -0,0 +1,172 @@ +# find-up + +> Find a file or directory by walking up parent directories + +## Install + +``` +$ npm install find-up +``` + +## Usage + +``` +/ +└── Users + └── sindresorhus + ├── unicorn.png + └── foo + └── bar + ├── baz + └── example.js +``` + +`example.js` + +```js +import path from 'node:path'; +import {findUp, pathExists} from 'find-up'; + +console.log(await findUp('unicorn.png')); +//=> '/Users/sindresorhus/unicorn.png' + +console.log(await findUp(['rainbow.png', 'unicorn.png'])); +//=> '/Users/sindresorhus/unicorn.png' + +console.log(await findUp(async directory => { + const hasUnicorns = await pathExists(path.join(directory, 'unicorn.png')); + return hasUnicorns && directory; +}, {type: 'directory'})); +//=> '/Users/sindresorhus' +``` + +## API + +### findUp(name, options?) +### findUp(matcher, options?) + +Returns a `Promise` for either the path or `undefined` if it couldn't be found. + +### findUp([...name], options?) + +Returns a `Promise` for either the first path found (by respecting the order of the array) or `undefined` if none could be found. + +### findUpMultiple(name, options?) +### findUpMultiple(matcher, options?) + +Returns a `Promise` for either an array of paths or an empty array if none could be found. + +### findUpMultiple([...name], options?) + +Returns a `Promise` for either an array of the first paths found (by respecting the order of the array) or an empty array if none could be found. + +### findUpSync(name, options?) +### findUpSync(matcher, options?) + +Returns a path or `undefined` if it couldn't be found. + +### findUpSync([...name], options?) + +Returns the first path found (by respecting the order of the array) or `undefined` if none could be found. + +### findUpMultipleSync(name, options?) +### findUpMultipleSync(matcher, options?) + +Returns an array of paths or an empty array if none could be found. + +### findUpMultipleSync([...name], options?) + +Returns an array of the first paths found (by respecting the order of the array) or an empty array if none could be found. + +#### name + +Type: `string` + +The name of the file or directory to find. + +#### matcher + +Type: `Function` + +A function that will be called with each directory until it returns a `string` with the path, which stops the search, or the root directory has been reached and nothing was found. Useful if you want to match files with certain patterns, set of permissions, or other advanced use-cases. + +When using async mode, the `matcher` may optionally be an async or promise-returning function that returns the path. + +#### options + +Type: `object` + +##### cwd + +Type: `URL | string`\ +Default: `process.cwd()` + +The directory to start from. + +##### type + +Type: `string`\ +Default: `'file'`\ +Values: `'file'` `'directory'` + +The type of paths that can match. + +##### allowSymlinks + +Type: `boolean`\ +Default: `true` + +Allow symbolic links to match if they point to the chosen path type. + +##### stopAt + +Type: `string`\ +Default: `path.parse(cwd).root` + +The path to the directory to stop the search before reaching root if there were no matches before the `stopAt` directory. + +### pathExists(path) + +Returns a `Promise` of whether the path exists. + +### pathExistsSync(path) + +Returns a `boolean` of whether the path exists. + +#### path + +Type: `string` + +The path to a file or directory. + +### findUpStop + +A [`Symbol`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol) that can be returned by a `matcher` function to stop the search and cause `findUp` to immediately return `undefined`. Useful as a performance optimization in case the current working directory is deeply nested in the filesystem. + +```js +import path from 'node:path'; +import {findUp, findUpStop} from 'find-up'; + +await findUp(directory => { + return path.basename(directory) === 'work' ? findUpStop : 'logo.png'; +}); +``` + +## Related + +- [find-up-cli](https://github.com/sindresorhus/find-up-cli) - CLI for this module +- [pkg-up](https://github.com/sindresorhus/pkg-up) - Find the closest package.json file +- [pkg-dir](https://github.com/sindresorhus/pkg-dir) - Find the root directory of an npm package +- [resolve-from](https://github.com/sindresorhus/resolve-from) - Resolve the path of a module like `require.resolve()` but from a given path + +--- + +
+ + Get professional support for 'find-up' with a Tidelift subscription + +
+ + Tidelift helps make open source sustainable for maintainers while giving companies
assurances about security, maintenance, and licensing for their dependencies. + +
diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/locate-path/index.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/locate-path/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4ecf24a2abf7b7c7bc1c66a8bbd39ce164467787 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/locate-path/index.d.ts @@ -0,0 +1,92 @@ +export interface Options { + /** + The current working directory. + + @default process.cwd() + */ + readonly cwd?: URL | string; + + /** + The type of path to match. + + @default 'file' + */ + readonly type?: 'file' | 'directory'; + + /** + Allow symbolic links to match if they point to the requested path type. + + @default true + */ + readonly allowSymlinks?: boolean; +} + +export interface AsyncOptions extends Options { + /** + The number of concurrently pending promises. + + Minimum: `1` + + @default Infinity + */ + readonly concurrency?: number; + + /** + Preserve `paths` order when searching. + + Disable this to improve performance if you don't care about the order. + + @default true + */ + readonly preserveOrder?: boolean; +} + +/** +Get the first path that exists on disk of multiple paths. + +@param paths - The paths to check. +@returns The first path that exists or `undefined` if none exists. + +@example +``` +import {locatePath} from 'locate-path'; + +const files = [ + 'unicorn.png', + 'rainbow.png', // Only this one actually exists on disk + 'pony.png' +]; + +console(await locatePath(files)); +//=> 'rainbow' +``` +*/ +export function locatePath( + paths: Iterable, + options?: AsyncOptions +): Promise; + +/** +Synchronously get the first path that exists on disk of multiple paths. + +@param paths - The paths to check. +@returns The first path that exists or `undefined` if none exists. + +@example +``` +import {locatePathSync} from 'locate-path'; + +const files = [ + 'unicorn.png', + 'rainbow.png', // Only this one actually exists on disk + 'pony.png' +]; + +console(locatePathSync(files)); +//=> 'rainbow' +``` +*/ +export function locatePathSync( + paths: Iterable, + options?: Options +): string | undefined; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/locate-path/index.js b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/locate-path/index.js new file mode 100644 index 0000000000000000000000000000000000000000..a5fed89ae7c37c061bf65e3e4c1ca751e8a2a686 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/locate-path/index.js @@ -0,0 +1,77 @@ +import process from 'node:process'; +import path from 'node:path'; +import fs, {promises as fsPromises} from 'node:fs'; +import {fileURLToPath} from 'node:url'; +import pLocate from 'p-locate'; + +const typeMappings = { + directory: 'isDirectory', + file: 'isFile', +}; + +function checkType(type) { + if (Object.hasOwnProperty.call(typeMappings, type)) { + return; + } + + throw new Error(`Invalid type specified: ${type}`); +} + +const matchType = (type, stat) => stat[typeMappings[type]](); + +const toPath = urlOrPath => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath; + +export async function locatePath( + paths, + { + cwd = process.cwd(), + type = 'file', + allowSymlinks = true, + concurrency, + preserveOrder, + } = {}, +) { + checkType(type); + cwd = toPath(cwd); + + const statFunction = allowSymlinks ? fsPromises.stat : fsPromises.lstat; + + return pLocate(paths, async path_ => { + try { + const stat = await statFunction(path.resolve(cwd, path_)); + return matchType(type, stat); + } catch { + return false; + } + }, {concurrency, preserveOrder}); +} + +export function locatePathSync( + paths, + { + cwd = process.cwd(), + type = 'file', + allowSymlinks = true, + } = {}, +) { + checkType(type); + cwd = toPath(cwd); + + const statFunction = allowSymlinks ? fs.statSync : fs.lstatSync; + + for (const path_ of paths) { + try { + const stat = statFunction(path.resolve(cwd, path_), { + throwIfNoEntry: false, + }); + + if (!stat) { + continue; + } + + if (matchType(type, stat)) { + return path_; + } + } catch {} + } +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/locate-path/license b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/locate-path/license new file mode 100644 index 0000000000000000000000000000000000000000..fa7ceba3eb4a9657a9db7f3ffca4e4e97a9019de --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/locate-path/license @@ -0,0 +1,9 @@ +MIT License + +Copyright (c) Sindre Sorhus (https://sindresorhus.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. diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/locate-path/package.json b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/locate-path/package.json new file mode 100644 index 0000000000000000000000000000000000000000..28a2bda90eb2bd95d08b486c4010cd946bc877b6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/locate-path/package.json @@ -0,0 +1,48 @@ +{ + "name": "locate-path", + "version": "7.2.0", + "description": "Get the first path that exists on disk of multiple paths", + "license": "MIT", + "repository": "sindresorhus/locate-path", + "funding": "https://github.com/sponsors/sindresorhus", + "author": { + "name": "Sindre Sorhus", + "email": "sindresorhus@gmail.com", + "url": "https://sindresorhus.com" + }, + "type": "module", + "exports": "./index.js", + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "scripts": { + "test": "xo && ava && tsd" + }, + "files": [ + "index.js", + "index.d.ts" + ], + "keywords": [ + "locate", + "path", + "paths", + "file", + "files", + "exists", + "find", + "finder", + "search", + "searcher", + "array", + "iterable", + "iterator" + ], + "dependencies": { + "p-locate": "^6.0.0" + }, + "devDependencies": { + "ava": "^3.15.0", + "tsd": "^0.17.0", + "xo": "^0.44.0" + } +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/locate-path/readme.md b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/locate-path/readme.md new file mode 100644 index 0000000000000000000000000000000000000000..ea871fd63ea56fbb274d68ffc851f7e06c54fe98 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/locate-path/readme.md @@ -0,0 +1,123 @@ +# locate-path + +> Get the first path that exists on disk of multiple paths + +## Install + +``` +$ npm install locate-path +``` + +## Usage + +Here we find the first file that exists on disk, in array order. + +```js +import {locatePath} from 'locate-path'; + +const files = [ + 'unicorn.png', + 'rainbow.png', // Only this one actually exists on disk + 'pony.png' +]; + +console(await locatePath(files)); +//=> 'rainbow' +``` + +## API + +### locatePath(paths, options?) + +Returns a `Promise` for the first path that exists or `undefined` if none exists. + +#### paths + +Type: `Iterable` + +The paths to check. + +#### options + +Type: `object` + +##### concurrency + +Type: `number`\ +Default: `Infinity`\ +Minimum: `1` + +The number of concurrently pending promises. + +##### preserveOrder + +Type: `boolean`\ +Default: `true` + +Preserve `paths` order when searching. + +Disable this to improve performance if you don't care about the order. + +##### cwd + +Type: `URL | string`\ +Default: `process.cwd()` + +The current working directory. + +##### type + +Type: `string`\ +Default: `'file'`\ +Values: `'file' | 'directory'` + +The type of paths that can match. + +##### allowSymlinks + +Type: `boolean`\ +Default: `true` + +Allow symbolic links to match if they point to the chosen path type. + +### locatePathSync(paths, options?) + +Returns the first path that exists or `undefined` if none exists. + +#### paths + +Type: `Iterable` + +The paths to check. + +#### options + +Type: `object` + +##### cwd + +Same as above. + +##### type + +Same as above. + +##### allowSymlinks + +Same as above. + +## Related + +- [path-exists](https://github.com/sindresorhus/path-exists) - Check if a path exists + +--- + +
+ + Get professional support for this package with a Tidelift subscription + +
+ + Tidelift helps make open source sustainable for maintainers while giving companies
assurances about security, maintenance, and licensing for their dependencies. + +
diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-limit/index.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-limit/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..caae030938fe9542988958c1206fb574adb59910 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-limit/index.d.ts @@ -0,0 +1,40 @@ +/* eslint-disable @typescript-eslint/member-ordering */ + +export interface LimitFunction { + /** + The number of promises that are currently running. + */ + readonly activeCount: number; + + /** + The number of promises that are waiting to run (i.e. their internal `fn` was not called yet). + */ + readonly pendingCount: number; + + /** + Discard pending promises that are waiting to run. + + This might be useful if you want to teardown the queue at the end of your program's lifecycle or discard any function calls referencing an intermediary state of your app. + + Note: This does not cancel promises that are already running. + */ + clearQueue: () => void; + + /** + @param fn - Promise-returning/async function. + @param arguments - Any arguments to pass through to `fn`. Support for passing arguments on to the `fn` is provided in order to be able to avoid creating unnecessary closures. You probably don't need this optimization unless you're pushing a lot of functions. + @returns The promise returned by calling `fn(...arguments)`. + */ + ( + fn: (...arguments: Arguments) => PromiseLike | ReturnType, + ...arguments: Arguments + ): Promise; +} + +/** +Run multiple promise-returning & async functions with limited concurrency. + +@param concurrency - Concurrency limit. Minimum: `1`. +@returns A `limit` function. +*/ +export default function pLimit(concurrency: number): LimitFunction; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-limit/index.js b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-limit/index.js new file mode 100644 index 0000000000000000000000000000000000000000..b54b99b09cbf26981000c36d5d7b5b5d6627ec8d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-limit/index.js @@ -0,0 +1,68 @@ +import Queue from 'yocto-queue'; + +export default function pLimit(concurrency) { + if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) { + throw new TypeError('Expected `concurrency` to be a number from 1 and up'); + } + + const queue = new Queue(); + let activeCount = 0; + + const next = () => { + activeCount--; + + if (queue.size > 0) { + queue.dequeue()(); + } + }; + + const run = async (fn, resolve, args) => { + activeCount++; + + const result = (async () => fn(...args))(); + + resolve(result); + + try { + await result; + } catch {} + + next(); + }; + + const enqueue = (fn, resolve, args) => { + queue.enqueue(run.bind(undefined, fn, resolve, args)); + + (async () => { + // This function needs to wait until the next microtask before comparing + // `activeCount` to `concurrency`, because `activeCount` is updated asynchronously + // when the run function is dequeued and called. The comparison in the if-statement + // needs to happen asynchronously as well to get an up-to-date value for `activeCount`. + await Promise.resolve(); + + if (activeCount < concurrency && queue.size > 0) { + queue.dequeue()(); + } + })(); + }; + + const generator = (fn, ...args) => new Promise(resolve => { + enqueue(fn, resolve, args); + }); + + Object.defineProperties(generator, { + activeCount: { + get: () => activeCount, + }, + pendingCount: { + get: () => queue.size, + }, + clearQueue: { + value: () => { + queue.clear(); + }, + }, + }); + + return generator; +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-limit/license b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-limit/license new file mode 100644 index 0000000000000000000000000000000000000000..fa7ceba3eb4a9657a9db7f3ffca4e4e97a9019de --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-limit/license @@ -0,0 +1,9 @@ +MIT License + +Copyright (c) Sindre Sorhus (https://sindresorhus.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. diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-limit/package.json b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-limit/package.json new file mode 100644 index 0000000000000000000000000000000000000000..2e41e6e172c99235b59e6cf5c9bd6592741c19d3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-limit/package.json @@ -0,0 +1,54 @@ +{ + "name": "p-limit", + "version": "4.0.0", + "description": "Run multiple promise-returning & async functions with limited concurrency", + "license": "MIT", + "repository": "sindresorhus/p-limit", + "funding": "https://github.com/sponsors/sindresorhus", + "author": { + "name": "Sindre Sorhus", + "email": "sindresorhus@gmail.com", + "url": "https://sindresorhus.com" + }, + "type": "module", + "exports": "./index.js", + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "scripts": { + "test": "xo && ava && tsd" + }, + "files": [ + "index.js", + "index.d.ts" + ], + "keywords": [ + "promise", + "limit", + "limited", + "concurrency", + "throttle", + "throat", + "rate", + "batch", + "ratelimit", + "task", + "queue", + "async", + "await", + "promises", + "bluebird" + ], + "dependencies": { + "yocto-queue": "^1.0.0" + }, + "devDependencies": { + "ava": "^3.15.0", + "delay": "^5.0.0", + "in-range": "^3.0.0", + "random-int": "^3.0.0", + "time-span": "^5.0.0", + "tsd": "^0.17.0", + "xo": "^0.44.0" + } +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-limit/readme.md b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-limit/readme.md new file mode 100644 index 0000000000000000000000000000000000000000..b02253bddc408bf09b60b2bbf9b2ab282f1cd790 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-limit/readme.md @@ -0,0 +1,99 @@ +# p-limit + +> Run multiple promise-returning & async functions with limited concurrency + +## Install + +``` +$ npm install p-limit +``` + +## Usage + +```js +import pLimit from 'p-limit'; + +const limit = pLimit(1); + +const input = [ + limit(() => fetchSomething('foo')), + limit(() => fetchSomething('bar')), + limit(() => doSomething()) +]; + +// Only one promise is run at once +const result = await Promise.all(input); +console.log(result); +``` + +## API + +### pLimit(concurrency) + +Returns a `limit` function. + +#### concurrency + +Type: `number`\ +Minimum: `1`\ +Default: `Infinity` + +Concurrency limit. + +### limit(fn, ...args) + +Returns the promise returned by calling `fn(...args)`. + +#### fn + +Type: `Function` + +Promise-returning/async function. + +#### args + +Any arguments to pass through to `fn`. + +Support for passing arguments on to the `fn` is provided in order to be able to avoid creating unnecessary closures. You probably don't need this optimization unless you're pushing a *lot* of functions. + +### limit.activeCount + +The number of promises that are currently running. + +### limit.pendingCount + +The number of promises that are waiting to run (i.e. their internal `fn` was not called yet). + +### limit.clearQueue() + +Discard pending promises that are waiting to run. + +This might be useful if you want to teardown the queue at the end of your program's lifecycle or discard any function calls referencing an intermediary state of your app. + +Note: This does not cancel promises that are already running. + +## FAQ + +### How is this different from the [`p-queue`](https://github.com/sindresorhus/p-queue) package? + +This package is only about limiting the number of concurrent executions, while `p-queue` is a fully featured queue implementation with lots of different options, introspection, and ability to pause the queue. + +## Related + +- [p-queue](https://github.com/sindresorhus/p-queue) - Promise queue with concurrency control +- [p-throttle](https://github.com/sindresorhus/p-throttle) - Throttle promise-returning & async functions +- [p-debounce](https://github.com/sindresorhus/p-debounce) - Debounce promise-returning & async functions +- [p-all](https://github.com/sindresorhus/p-all) - Run promise-returning & async functions concurrently with optional limited concurrency +- [More…](https://github.com/sindresorhus/promise-fun) + +--- + +
+ + Get professional support for this package with a Tidelift subscription + +
+ + Tidelift helps make open source sustainable for maintainers while giving companies
assurances about security, maintenance, and licensing for their dependencies. + +
diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-locate/index.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-locate/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..43b89dadedac38116ba6271635b91158304542c9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-locate/index.d.ts @@ -0,0 +1,49 @@ +export interface Options { + /** + The number of concurrently pending promises returned by `tester`. + + Minimum: `1` + + @default Infinity + */ + readonly concurrency?: number; + + /** + Preserve `input` order when searching. + + Disable this to improve performance if you don't care about the order. + + @default true + */ + readonly preserveOrder?: boolean; +} + +/** +Get the first fulfilled promise that satisfies the provided testing function. + +@param input - An iterable of promises/values to test. +@param tester - This function will receive resolved values from `input` and is expected to return a `Promise` or `boolean`. +@returns A `Promise` that is fulfilled when `tester` resolves to `true` or the iterable is done, or rejects if any of the promises reject. The fulfilled value is the current iterable value or `undefined` if `tester` never resolved to `true`. + +@example +``` +import {pathExists} from 'path-exists'; +import pLocate from 'p-locate'; + +const files = [ + 'unicorn.png', + 'rainbow.png', // Only this one actually exists on disk + 'pony.png' +]; + +const foundPath = await pLocate(files, file => pathExists(file)); + +console.log(foundPath); +//=> 'rainbow' +``` +*/ +export default function pLocate( + input: Iterable | ValueType>, + tester: (element: ValueType) => PromiseLike | boolean, + options?: Options +): Promise; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-locate/index.js b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-locate/index.js new file mode 100644 index 0000000000000000000000000000000000000000..5b386369a0986365d27b02e915468ae4a0e3fb18 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-locate/index.js @@ -0,0 +1,48 @@ +import pLimit from 'p-limit'; + +class EndError extends Error { + constructor(value) { + super(); + this.value = value; + } +} + +// The input can also be a promise, so we await it. +const testElement = async (element, tester) => tester(await element); + +// The input can also be a promise, so we `Promise.all()` them both. +const finder = async element => { + const values = await Promise.all(element); + if (values[1] === true) { + throw new EndError(values[0]); + } + + return false; +}; + +export default async function pLocate( + iterable, + tester, + { + concurrency = Number.POSITIVE_INFINITY, + preserveOrder = true, + } = {}, +) { + const limit = pLimit(concurrency); + + // Start all the promises concurrently with optional limit. + const items = [...iterable].map(element => [element, limit(testElement, element, tester)]); + + // Check the promises either serially or concurrently. + const checkLimit = pLimit(preserveOrder ? 1 : Number.POSITIVE_INFINITY); + + try { + await Promise.all(items.map(element => checkLimit(finder, element))); + } catch (error) { + if (error instanceof EndError) { + return error.value; + } + + throw error; + } +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-locate/license b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-locate/license new file mode 100644 index 0000000000000000000000000000000000000000..fa7ceba3eb4a9657a9db7f3ffca4e4e97a9019de --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-locate/license @@ -0,0 +1,9 @@ +MIT License + +Copyright (c) Sindre Sorhus (https://sindresorhus.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. diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-locate/package.json b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-locate/package.json new file mode 100644 index 0000000000000000000000000000000000000000..a20cb6ff81072be0961b28ac6ce0900d7c2a1395 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-locate/package.json @@ -0,0 +1,56 @@ +{ + "name": "p-locate", + "version": "6.0.0", + "description": "Get the first fulfilled promise that satisfies the provided testing function", + "license": "MIT", + "repository": "sindresorhus/p-locate", + "funding": "https://github.com/sponsors/sindresorhus", + "author": { + "name": "Sindre Sorhus", + "email": "sindresorhus@gmail.com", + "url": "https://sindresorhus.com" + }, + "type": "module", + "exports": "./index.js", + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "scripts": { + "test": "xo && ava && tsd" + }, + "files": [ + "index.js", + "index.d.ts" + ], + "keywords": [ + "promise", + "locate", + "find", + "finder", + "search", + "searcher", + "test", + "array", + "collection", + "iterable", + "iterator", + "race", + "fulfilled", + "fastest", + "async", + "await", + "promises", + "bluebird" + ], + "dependencies": { + "p-limit": "^4.0.0" + }, + "devDependencies": { + "ava": "^3.15.0", + "delay": "^5.0.0", + "in-range": "^3.0.0", + "time-span": "^5.0.0", + "tsd": "^0.17.0", + "xo": "^0.44.0" + } +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-locate/readme.md b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-locate/readme.md new file mode 100644 index 0000000000000000000000000000000000000000..9a2c0e3208d45f16e1b33ee08f9cb0ba0cdb1f20 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/p-locate/readme.md @@ -0,0 +1,91 @@ +# p-locate + +> Get the first fulfilled promise that satisfies the provided testing function + +Think of it like an async version of [`Array#find`](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/find). + +## Install + +``` +$ npm install p-locate +``` + +## Usage + +Here we find the first file that exists on disk, in array order. + +```js +import {pathExists} from 'path-exists'; +import pLocate from 'p-locate'; + +const files = [ + 'unicorn.png', + 'rainbow.png', // Only this one actually exists on disk + 'pony.png' +]; + +const foundPath = await pLocate(files, file => pathExists(file)); + +console.log(foundPath); +//=> 'rainbow' +``` + +*The above is just an example. Use [`locate-path`](https://github.com/sindresorhus/locate-path) if you need this.* + +## API + +### pLocate(input, tester, options?) + +Returns a `Promise` that is fulfilled when `tester` resolves to `true` or the iterable is done, or rejects if any of the promises reject. The fulfilled value is the current iterable value or `undefined` if `tester` never resolved to `true`. + +#### input + +Type: `Iterable` + +An iterable of promises/values to test. + +#### tester(element) + +Type: `Function` + +This function will receive resolved values from `input` and is expected to return a `Promise` or `boolean`. + +#### options + +Type: `object` + +##### concurrency + +Type: `number`\ +Default: `Infinity`\ +Minimum: `1` + +The number of concurrently pending promises returned by `tester`. + +##### preserveOrder + +Type: `boolean`\ +Default: `true` + +Preserve `input` order when searching. + +Disable this to improve performance if you don't care about the order. + +## Related + +- [p-map](https://github.com/sindresorhus/p-map) - Map over promises concurrently +- [p-filter](https://github.com/sindresorhus/p-filter) - Filter promises concurrently +- [p-any](https://github.com/sindresorhus/p-any) - Wait for any promise to be fulfilled +- [More…](https://github.com/sindresorhus/promise-fun) + +--- + +
+ + Get professional support for this package with a Tidelift subscription + +
+ + Tidelift helps make open source sustainable for maintainers while giving companies
assurances about security, maintenance, and licensing for their dependencies. + +
diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/path-exists/index.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/path-exists/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..3251306ce32d586bcf600d024bd5207cd98ae670 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/path-exists/index.d.ts @@ -0,0 +1,31 @@ +/** +Check if a path exists. + +@returns Whether the path exists. + +@example +``` +// foo.ts +import {pathExists} from 'path-exists'; + +console.log(await pathExists('foo.ts')); +//=> true +``` +*/ +export function pathExists(path: string): Promise; + +/** +Synchronously check if a path exists. + +@returns Whether the path exists. + +@example +``` +// foo.ts +import {pathExistsSync} from 'path-exists'; + +console.log(pathExistsSync('foo.ts')); +//=> true +``` +*/ +export function pathExistsSync(path: string): boolean; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/path-exists/index.js b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/path-exists/index.js new file mode 100644 index 0000000000000000000000000000000000000000..ef6443b1ad812ab12f3fb1139d2064553f0399e1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/path-exists/index.js @@ -0,0 +1,19 @@ +import fs, {promises as fsPromises} from 'node:fs'; + +export async function pathExists(path) { + try { + await fsPromises.access(path); + return true; + } catch { + return false; + } +} + +export function pathExistsSync(path) { + try { + fs.accessSync(path); + return true; + } catch { + return false; + } +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/path-exists/license b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/path-exists/license new file mode 100644 index 0000000000000000000000000000000000000000..fa7ceba3eb4a9657a9db7f3ffca4e4e97a9019de --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/path-exists/license @@ -0,0 +1,9 @@ +MIT License + +Copyright (c) Sindre Sorhus (https://sindresorhus.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. diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/path-exists/package.json b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/path-exists/package.json new file mode 100644 index 0000000000000000000000000000000000000000..f5bde2ba4fd0f05d7fb9067103ef9bffb139baf7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/path-exists/package.json @@ -0,0 +1,41 @@ +{ + "name": "path-exists", + "version": "5.0.0", + "description": "Check if a path exists", + "license": "MIT", + "repository": "sindresorhus/path-exists", + "author": { + "name": "Sindre Sorhus", + "email": "sindresorhus@gmail.com", + "url": "https://sindresorhus.com" + }, + "type": "module", + "exports": "./index.js", + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "scripts": { + "test": "xo && ava && tsd" + }, + "files": [ + "index.js", + "index.d.ts" + ], + "keywords": [ + "path", + "exists", + "exist", + "file", + "filepath", + "fs", + "filesystem", + "file-system", + "access", + "stat" + ], + "devDependencies": { + "ava": "^3.15.0", + "tsd": "^0.17.0", + "xo": "^0.44.0" + } +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/path-exists/readme.md b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/path-exists/readme.md new file mode 100644 index 0000000000000000000000000000000000000000..067b00c5f8896c39fbf16b86f23da440a06f3de3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/path-exists/readme.md @@ -0,0 +1,52 @@ +# path-exists + +> Check if a path exists + +NOTE: `fs.existsSync` has been un-deprecated in Node.js since 6.8.0. If you only need to check synchronously, this module is not needed. + +Never use this before handling a file though: + +> In particular, checking if a file exists before opening it is an anti-pattern that leaves you vulnerable to race conditions: another process may remove the file between the calls to `fs.exists()` and `fs.open()`. Just open the file and handle the error when it's not there. + +## Install + +``` +$ npm install path-exists +``` + +## Usage + +```js +// foo.js +import {pathExists} from 'path-exists'; + +console.log(await pathExists('foo.js')); +//=> true +``` + +## API + +### pathExists(path) + +Returns a `Promise` of whether the path exists. + +### pathExistsSync(path) + +Returns a `boolean` of whether the path exists. + +## Related + +- [path-exists-cli](https://github.com/sindresorhus/path-exists-cli) - CLI for this module +- [path-type](https://github.com/sindresorhus/path-type) - Check if a path exists and whether it's a file, directory, or symlink + +--- + +
+ + Get professional support for this package with a Tidelift subscription + +
+ + Tidelift helps make open source sustainable for maintainers while giving companies
assurances about security, maintenance, and licensing for their dependencies. + +
diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/index.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ee20662e47cd1110d80a4fc6d8176c9872cd2b1b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/index.d.ts @@ -0,0 +1,95 @@ +// Basic +export * from './source/primitive'; +export * from './source/typed-array'; +export * from './source/basic'; +export * from './source/observable-like'; + +// Utilities +export {Except} from './source/except'; +export {Mutable} from './source/mutable'; +export {Writable} from './source/writable'; +export {Merge} from './source/merge'; +export {MergeExclusive} from './source/merge-exclusive'; +export {RequireAtLeastOne} from './source/require-at-least-one'; +export {RequireExactlyOne} from './source/require-exactly-one'; +export {RequireAllOrNone} from './source/require-all-or-none'; +export {RemoveIndexSignature} from './source/remove-index-signature'; +export {PartialDeep, PartialDeepOptions} from './source/partial-deep'; +export {PartialOnUndefinedDeep, PartialOnUndefinedDeepOptions} from './source/partial-on-undefined-deep'; +export {ReadonlyDeep} from './source/readonly-deep'; +export {LiteralUnion} from './source/literal-union'; +export {Promisable} from './source/promisable'; +export {Opaque, UnwrapOpaque} from './source/opaque'; +export {InvariantOf} from './source/invariant-of'; +export {SetOptional} from './source/set-optional'; +export {SetRequired} from './source/set-required'; +export {SetNonNullable} from './source/set-non-nullable'; +export {ValueOf} from './source/value-of'; +export {PromiseValue} from './source/promise-value'; +export {AsyncReturnType} from './source/async-return-type'; +export {ConditionalExcept} from './source/conditional-except'; +export {ConditionalKeys} from './source/conditional-keys'; +export {ConditionalPick} from './source/conditional-pick'; +export {UnionToIntersection} from './source/union-to-intersection'; +export {Stringified} from './source/stringified'; +export {FixedLengthArray} from './source/fixed-length-array'; +export {MultidimensionalArray} from './source/multidimensional-array'; +export {MultidimensionalReadonlyArray} from './source/multidimensional-readonly-array'; +export {IterableElement} from './source/iterable-element'; +export {Entry} from './source/entry'; +export {Entries} from './source/entries'; +export {SetReturnType} from './source/set-return-type'; +export {Asyncify} from './source/asyncify'; +export {Simplify, SimplifyOptions} from './source/simplify'; +export {Jsonify} from './source/jsonify'; +export {Schema} from './source/schema'; +export {LiteralToPrimitive} from './source/literal-to-primitive'; +export { + PositiveInfinity, + NegativeInfinity, + Finite, + Integer, + Float, + NegativeFloat, + Negative, + NonNegative, + NegativeInteger, + NonNegativeInteger, +} from './source/numeric'; +export {StringKeyOf} from './source/string-key-of'; +export {Exact} from './source/exact'; +export {ReadonlyTuple} from './source/readonly-tuple'; +export {OptionalKeysOf} from './source/optional-keys-of'; +export {HasOptionalKeys} from './source/has-optional-keys'; +export {RequiredKeysOf} from './source/required-keys-of'; +export {HasRequiredKeys} from './source/has-required-keys'; +export {Spread} from './source/spread'; + +// Template literal types +export {CamelCase} from './source/camel-case'; +export {CamelCasedProperties} from './source/camel-cased-properties'; +export {CamelCasedPropertiesDeep} from './source/camel-cased-properties-deep'; +export {KebabCase} from './source/kebab-case'; +export {KebabCasedProperties} from './source/kebab-cased-properties'; +export {KebabCasedPropertiesDeep} from './source/kebab-cased-properties-deep'; +export {PascalCase} from './source/pascal-case'; +export {PascalCasedProperties} from './source/pascal-cased-properties'; +export {PascalCasedPropertiesDeep} from './source/pascal-cased-properties-deep'; +export {SnakeCase} from './source/snake-case'; +export {SnakeCasedProperties} from './source/snake-cased-properties'; +export {SnakeCasedPropertiesDeep} from './source/snake-cased-properties-deep'; +export {ScreamingSnakeCase} from './source/screaming-snake-case'; +export {DelimiterCase} from './source/delimiter-case'; +export {DelimiterCasedProperties} from './source/delimiter-cased-properties'; +export {DelimiterCasedPropertiesDeep} from './source/delimiter-cased-properties-deep'; +export {Join} from './source/join'; +export {Split} from './source/split'; +export {Trim} from './source/trim'; +export {Replace} from './source/replace'; +export {Includes} from './source/includes'; +export {Get} from './source/get'; +export {LastArrayElement} from './source/last-array-element'; + +// Miscellaneous +export {PackageJson} from './source/package-json'; +export {TsConfigJson} from './source/tsconfig-json'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/package.json b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/package.json new file mode 100644 index 0000000000000000000000000000000000000000..319558a283fcbc7f888a4cc0c305e77cdc6a1951 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/package.json @@ -0,0 +1,52 @@ +{ + "name": "type-fest", + "version": "2.19.0", + "description": "A collection of essential TypeScript types", + "license": "(MIT OR CC0-1.0)", + "repository": "sindresorhus/type-fest", + "funding": "https://github.com/sponsors/sindresorhus", + "author": { + "name": "Sindre Sorhus", + "email": "sindresorhus@gmail.com", + "url": "https://sindresorhus.com" + }, + "engines": { + "node": ">=12.20" + }, + "scripts": { + "test": "xo && tsd && tsc && node script/test/source-files-extension.js" + }, + "files": [ + "index.d.ts", + "source" + ], + "keywords": [ + "typescript", + "ts", + "types", + "utility", + "util", + "utilities", + "omit", + "merge", + "json" + ], + "devDependencies": { + "@sindresorhus/tsconfig": "~0.7.0", + "expect-type": "^0.13.0", + "tsd": "^0.20.0", + "typescript": "^4.6.3", + "xo": "^0.43.0" + }, + "types": "./index.d.ts", + "xo": { + "rules": { + "@typescript-eslint/ban-types": "off", + "@typescript-eslint/indent": "off", + "node/no-unsupported-features/es-builtins": "off", + "import/extensions": "off", + "@typescript-eslint/no-redeclare": "off", + "@typescript-eslint/no-confusing-void-expression": "off" + } + } +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/readme.md b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/readme.md new file mode 100644 index 0000000000000000000000000000000000000000..0d310aad73da4bde9b1eefacdf61ba48cbd53651 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/readme.md @@ -0,0 +1,905 @@ +
+
+
+ type-fest +
+
+ A collection of essential TypeScript types +
+
+
+
+
+ +
+
+
+
+
+ +[![](https://img.shields.io/badge/unicorn-approved-ff69b4.svg)](https://giphy.com/gifs/illustration-rainbow-unicorn-26AHG5KGFxSkUWw1i) +[![npm dependents](https://badgen.net/npm/dependents/type-fest)](https://www.npmjs.com/package/type-fest?activeTab=dependents) +[![npm downloads](https://badgen.net/npm/dt/type-fest)](https://www.npmjs.com/package/type-fest) +[![Docs](https://paka.dev/badges/v0/cute.svg)](https://paka.dev/npm/type-fest) + +Many of the types here should have been built-in. You can help by suggesting some of them to the [TypeScript project](https://github.com/Microsoft/TypeScript/blob/main/CONTRIBUTING.md). + +Either add this package as a dependency or copy-paste the needed types. No credit required. 👌 + +PR welcome for additional commonly needed types and docs improvements. Read the [contributing guidelines](.github/contributing.md) first. + +**Help wanted with reviewing [proposals](https://github.com/sindresorhus/type-fest/issues) and [pull requests](https://github.com/sindresorhus/type-fest/pulls).** + +## Install + +```sh +npm install type-fest +``` + +*Requires TypeScript >=4.2* + +## Usage + +```ts +import type {Except} from 'type-fest'; + +type Foo = { + unicorn: string; + rainbow: boolean; +}; + +type FooWithoutRainbow = Except; +//=> {unicorn: string} +``` + +## API + +Click the type names for complete docs. + +### Basic + +- [`Primitive`](source/primitive.d.ts) - Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive). +- [`Class`](source/basic.d.ts) - Matches a [`class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes). +- [`Constructor`](source/basic.d.ts) - Matches a [`class` constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes). +- [`TypedArray`](source/typed-array.d.ts) - Matches any [typed array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray), like `Uint8Array` or `Float64Array`. +- [`ObservableLike`](source/observable-like.d.ts) - Matches a value that is like an [Observable](https://github.com/tc39/proposal-observable). + +### Utilities + +- [`Except`](source/except.d.ts) - Create a type from an object type without certain keys. This is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/utility-types.html#omittype-keys). +- [`Writable`](source/writable.d.ts) - Create a type that strips `readonly` from all or some of an object's keys. The inverse of `Readonly`. Formerly named `Mutable`. +- [`Merge`](source/merge.d.ts) - Merge two types into a new type. Keys of the second type overrides keys of the first type. +- [`MergeExclusive`](source/merge-exclusive.d.ts) - Create a type that has mutually exclusive keys. +- [`RequireAtLeastOne`](source/require-at-least-one.d.ts) - Create a type that requires at least one of the given keys. +- [`RequireExactlyOne`](source/require-exactly-one.d.ts) - Create a type that requires exactly a single key of the given keys and disallows more. +- [`RequireAllOrNone`](source/require-all-or-none.d.ts) - Create a type that requires all of the given keys or none of the given keys. +- [`RemoveIndexSignature`](source/remove-index-signature.d.ts) - Create a type that only has explicitly defined properties, absent of any index signatures. +- [`PartialDeep`](source/partial-deep.d.ts) - Create a deeply optional version of another type. Use [`Partial`](https://www.typescriptlang.org/docs/handbook/utility-types.html#partialtype) if you only need one level deep. +- [`PartialOnUndefinedDeep`](source/partial-on-undefined-deep.d.ts) - Create a deep version of another type where all keys accepting `undefined` type are set to optional. +- [`ReadonlyDeep`](source/readonly-deep.d.ts) - Create a deeply immutable version of an `object`/`Map`/`Set`/`Array` type. Use [`Readonly`](https://www.typescriptlang.org/docs/handbook/utility-types.html#readonlytype) if you only need one level deep. +- [`LiteralUnion`](source/literal-union.d.ts) - Create a union type by combining primitive types and literal types without sacrificing auto-completion in IDEs for the literal type part of the union. Workaround for [Microsoft/TypeScript#29729](https://github.com/Microsoft/TypeScript/issues/29729). +- [`Opaque`](source/opaque.d.ts) - Create an [opaque type](https://codemix.com/opaque-types-in-javascript/). +- [`UnwrapOpaque`](source/opaque.d.ts) - Revert an [opaque type](https://codemix.com/opaque-types-in-javascript/) back to its original type. +- [`InvariantOf`](source/invariant-of.d.ts) - Create an [invariant type](https://basarat.gitbook.io/typescript/type-system/type-compatibility#footnote-invariance), which is a type that does not accept supertypes and subtypes. +- [`SetOptional`](source/set-optional.d.ts) - Create a type that makes the given keys optional. +- [`SetRequired`](source/set-required.d.ts) - Create a type that makes the given keys required. +- [`SetNonNullable`](source/set-non-nullable.d.ts) - Create a type that makes the given keys non-nullable. +- [`ValueOf`](source/value-of.d.ts) - Create a union of the given object's values, and optionally specify which keys to get the values from. +- [`ConditionalKeys`](source/conditional-keys.d.ts) - Extract keys from a shape where values extend the given `Condition` type. +- [`ConditionalPick`](source/conditional-pick.d.ts) - Like `Pick` except it selects properties from a shape where the values extend the given `Condition` type. +- [`ConditionalExcept`](source/conditional-except.d.ts) - Like `Omit` except it removes properties from a shape where the values extend the given `Condition` type. +- [`UnionToIntersection`](source/union-to-intersection.d.ts) - Convert a union type to an intersection type. +- [`LiteralToPrimitive`](source/literal-to-primitive.d.ts) - Convert a [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types) to the [primitive type](source/primitive.d.ts) it belongs to. +- [`Stringified`](source/stringified.d.ts) - Create a type with the keys of the given type changed to `string` type. +- [`IterableElement`](source/iterable-element.d.ts) - Get the element type of an `Iterable`/`AsyncIterable`. For example, an array or a generator. +- [`Entry`](source/entry.d.ts) - Create a type that represents the type of an entry of a collection. +- [`Entries`](source/entries.d.ts) - Create a type that represents the type of the entries of a collection. +- [`SetReturnType`](source/set-return-type.d.ts) - Create a function type with a return type of your choice and the same parameters as the given function type. +- [`Simplify`](source/simplify.d.ts) - Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability. +- [`Get`](source/get.d.ts) - Get a deeply-nested property from an object using a key path, like [Lodash's `.get()`](https://lodash.com/docs/latest#get) function. +- [`StringKeyOf`](source/string-key-of.d.ts) - Get keys of the given type as strings. +- [`Schema`](source/schema.d.ts) - Create a deep version of another object type where property values are recursively replaced into a given value type. +- [`Exact`](source/exact.d.ts) - Create a type that does not allow extra properties. +- [`OptionalKeysOf`](source/optional-keys-of.d.ts) - Extract all optional keys from the given type. +- [`HasOptionalKeys`](source/has-optional-keys.d.ts) - Create a `true`/`false` type depending on whether the given type has any optional fields. +- [`RequiredKeysOf`](source/required-keys-of.d.ts) - Extract all required keys from the given type. +- [`HasRequiredKeys`](source/has-required-keys.d.ts) - Create a `true`/`false` type depending on whether the given type has any required fields. +- [`Spread`](source/spread.d.ts) - Mimic the type inferred by TypeScript when merging two objects or two arrays/tuples using the spread syntax. + +### JSON + +- [`Jsonify`](source/jsonify.d.ts) - Transform a type to one that is assignable to the `JsonValue` type. +- [`JsonPrimitive`](source/basic.d.ts) - Matches a JSON primitive. +- [`JsonObject`](source/basic.d.ts) - Matches a JSON object. +- [`JsonArray`](source/basic.d.ts) - Matches a JSON array. +- [`JsonValue`](source/basic.d.ts) - Matches any valid JSON value. + +### Async + +- [`Promisable`](source/promisable.d.ts) - Create a type that represents either the value or the value wrapped in `PromiseLike`. +- [`AsyncReturnType`](source/async-return-type.d.ts) - Unwrap the return type of a function that returns a `Promise`. +- [`Asyncify`](source/asyncify.d.ts) - Create an async version of the given function type. + +### String + +- [`Trim`](source/trim.d.ts) - Remove leading and trailing spaces from a string. +- [`Split`](source/split.d.ts) - Represents an array of strings split using a given character or character set. +- [`Replace`](source/replace.d.ts) - Represents a string with some or all matches replaced by a replacement. + +### Array + +- [`Includes`](source/includes.d.ts) - Returns a boolean for whether the given array includes the given item. +- [`Join`](source/join.d.ts) - Join an array of strings and/or numbers using the given string as a delimiter. +- [`LastArrayElement`](source/last-array-element.d.ts) - Extracts the type of the last element of an array. +- [`FixedLengthArray`](source/fixed-length-array.d.ts) - Create a type that represents an array of the given type and length. +- [`MultidimensionalArray`](source/multidimensional-array.d.ts) - Create a type that represents a multidimensional array of the given type and dimensions. +- [`MultidimensionalReadonlyArray`](source/multidimensional-readonly-array.d.ts) - Create a type that represents a multidimensional readonly array of the given type and dimensions. +- [`ReadonlyTuple`](source/readonly-tuple.d.ts) - Create a type that represents a read-only tuple of the given type and length. + +### Numeric + +- [`PositiveInfinity`](source/numeric.d.ts) - Matches the hidden `Infinity` type. +- [`NegativeInfinity`](source/numeric.d.ts) - Matches the hidden `-Infinity` type. +- [`Finite`](source/numeric.d.ts) - A finite `number`. +- [`Integer`](source/numeric.d.ts) - A `number` that is an integer. +- [`Float`](source/numeric.d.ts) - A `number` that is not an integer. +- [`NegativeFloat`](source/numeric.d.ts) - A negative (`-∞ < x < 0`) `number` that is not an integer. +- [`Negative`](source/numeric.d.ts) - A negative `number`/`bigint` (`-∞ < x < 0`) +- [`NonNegative`](source/numeric.d.ts) - A non-negative `number`/`bigint` (`0 <= x < ∞`). +- [`NegativeInteger`](source/numeric.d.ts) - A negative (`-∞ < x < 0`) `number` that is an integer. +- [`NonNegativeInteger`](source/numeric.d.ts) - A non-negative (`0 <= x < ∞`) `number` that is an integer. + +### Change case + +- [`CamelCase`](source/camel-case.d.ts) - Convert a string literal to camel-case (`fooBar`). +- [`CamelCasedProperties`](source/camel-cased-properties.d.ts) - Convert object properties to camel-case (`fooBar`). +- [`CamelCasedPropertiesDeep`](source/camel-cased-properties-deep.d.ts) - Convert object properties to camel-case recursively (`fooBar`). +- [`KebabCase`](source/kebab-case.d.ts) - Convert a string literal to kebab-case (`foo-bar`). +- [`KebabCasedProperties`](source/kebab-cased-properties.d.ts) - Convert a object properties to kebab-case recursively (`foo-bar`). +- [`KebabCasedPropertiesDeep`](source/kebab-cased-properties-deep.d.ts) - Convert object properties to kebab-case (`foo-bar`). +- [`PascalCase`](source/pascal-case.d.ts) - Converts a string literal to pascal-case (`FooBar`) +- [`PascalCasedProperties`](source/pascal-cased-properties.d.ts) - Converts object properties to pascal-case (`FooBar`) +- [`PascalCasedPropertiesDeep`](source/pascal-cased-properties-deep.d.ts) - Converts object properties to pascal-case (`FooBar`) +- [`SnakeCase`](source/snake-case.d.ts) - Convert a string literal to snake-case (`foo_bar`). +- [`SnakeCasedProperties`](source/snake-cased-properties-deep.d.ts) - Convert object properties to snake-case (`foo_bar`). +- [`SnakeCasedPropertiesDeep`](source/snake-cased-properties-deep.d.ts) - Convert object properties to snake-case recursively (`foo_bar`). +- [`ScreamingSnakeCase`](source/screaming-snake-case.d.ts) - Convert a string literal to screaming-snake-case (`FOO_BAR`). +- [`DelimiterCase`](source/delimiter-case.d.ts) - Convert a string literal to a custom string delimiter casing. +- [`DelimiterCasedProperties`](source/delimiter-cased-properties.d.ts) - Convert object properties to a custom string delimiter casing. +- [`DelimiterCasedPropertiesDeep`](source/delimiter-cased-properties-deep.d.ts) - Convert object properties to a custom string delimiter casing recursively. + +### Miscellaneous + +- [`PackageJson`](source/package-json.d.ts) - Type for [npm's `package.json` file](https://docs.npmjs.com/creating-a-package-json-file). It also includes support for [TypeScript Declaration Files](https://www.typescriptlang.org/docs/handbook/declaration-files/publishing.html) and [Yarn Workspaces](https://classic.yarnpkg.com/lang/en/docs/workspaces/). +- [`TsConfigJson`](source/tsconfig-json.d.ts) - Type for [TypeScript's `tsconfig.json` file](https://www.typescriptlang.org/docs/handbook/tsconfig-json.html) (TypeScript 4.4). + +## Declined types + +*If we decline a type addition, we will make sure to document the better solution here.* + +- [`Diff` and `Spread`](https://github.com/sindresorhus/type-fest/pull/7) - The pull request author didn't provide any real-world use-cases and the PR went stale. If you think this type is useful, provide some real-world use-cases and we might reconsider. +- [`Dictionary`](https://github.com/sindresorhus/type-fest/issues/33) - You only save a few characters (`Dictionary` vs `Record`) from [`Record`](https://www.typescriptlang.org/docs/handbook/utility-types.html#recordkeys-type), which is more flexible and well-known. Also, you shouldn't use an object as a dictionary. We have `Map` in JavaScript now. +- [`ExtractProperties` and `ExtractMethods`](https://github.com/sindresorhus/type-fest/pull/4) - The types violate the single responsibility principle. Instead, refine your types into more granular type hierarchies. +- [`Url2Json`](https://github.com/sindresorhus/type-fest/pull/262) - Inferring search parameters from a URL string is a cute idea, but not very useful in practice, since search parameters are usually dynamic and defined separately. +- [`Nullish`](https://github.com/sindresorhus/type-fest/pull/318) - The type only saves a couple of characters, not everyone knows what "nullish" means, and I'm also trying to [get away from `null`](https://github.com/sindresorhus/meta/discussions/7). +- [`TitleCase`](https://github.com/sindresorhus/type-fest/pull/303) - It's not solving a common need and is a better fit for a separate package. +- [`ExtendOr` and `ExtendAnd`](https://github.com/sindresorhus/type-fest/pull/247) - The benefits don't outweigh having to learn what they mean. +- [`PackageJsonExtras`](https://github.com/sindresorhus/type-fest/issues/371) - There are too many possible configurations that can be put into `package.json`. If you would like to extend `PackageJson` to support an additional configuration in your project, please see the *Extending existing types* section below. + +## Alternative type names + +*If you know one of our types by a different name, add it here for discovery.* + +- `PartialBy` - See [`SetOptional`](https://github.com/sindresorhus/type-fest/blob/main/source/set-optional.d.ts) +- `RecordDeep`- See [`Schema`](https://github.com/sindresorhus/type-fest/blob/main/source/schema.d.ts) + +## Tips + +### Extending existing types + +- [`PackageJson`](source/package-json.d.ts) - There are a lot of tools that place extra configurations inside the `package.json` file. You can extend `PackageJson` to support these additional configurations. +
+ + Example + + + [Playground](https://www.typescriptlang.org/play?#code/JYWwDg9gTgLgBDAnmApnA3gBQIYGMDW2A5igFIDOEAdnNuXAEJ0o4HFmVUC+cAZlBBBwA5ElQBaXinIxhAbgCwAKFCRYCZGnQAZYFRgooPfoJHSANntmKlysWlaESFanAC8jZo-YuaAMgwLKwBhal5gIgB+AC44XX1DADpQqnCiLhsgA) + + ```ts + import type {PackageJson as BasePackageJson} from 'type-fest'; + import type {Linter} from 'eslint'; + + type PackageJson = BasePackageJson & {eslintConfig?: Linter.Config}; + ``` +
+ +### Related + +- [typed-query-selector](https://github.com/g-plane/typed-query-selector) - Enhances `document.querySelector` and `document.querySelectorAll` with a template literal type that matches element types returned from an HTML element query selector. +- [`Linter.Config`](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/eslint/index.d.ts) - Definitions for the [ESLint configuration schema](https://eslint.org/docs/user-guide/configuring/language-options). + +### Built-in types + +There are many advanced types most users don't know about. + +- [`Partial`](https://www.typescriptlang.org/docs/handbook/utility-types.html#partialtype) - Make all properties in `T` optional. +
+ + Example + + + [Playground](https://www.typescriptlang.org/play/#code/JYOwLgpgTgZghgYwgAgHIHsAmEDC6QzADmyA3gLABQyycADnanALYQBcyAzmFKEQNxUaddFDAcQAV2YAjaIMoBfKlQQAbOJ05osEAIIMAQpOBrsUMkOR1eANziRkCfISKSoD4Pg4ZseAsTIALyW1DS0DEysHADkvvoMMQA0VsKi4sgAzAAMuVaKClY2wPaOknSYDrguADwA0sgQAB6QIJjaANYQAJ7oMDp+LsQAfAAUXd0cdUnI9mo+uv6uANp1ALoAlKHhyGAAFsCcAHTOAW4eYF4gyxNrwbNwago0ypRWp66jH8QcAApwYmAjxq8SWIy2FDCNDA3ToKFBQyIdR69wmfQG1TOhShyBgomQX3w3GQE2Q6IA8jIAFYQBBgI4TTiEs5bTQYsFInrLTbbHZOIlgZDlSqQABqj0kKBC3yINx6a2xfOQwH6o2FVXFaklwSCIUkbQghBAEEwENSfNOlykEGefNe5uhB2O6sgS3GPRmLogmslG1tLxUOKgEDA7hAuydtteryAA) + + ```ts + interface NodeConfig { + appName: string; + port: number; + } + + class NodeAppBuilder { + private configuration: NodeConfig = { + appName: 'NodeApp', + port: 3000 + }; + + private updateConfig(key: Key, value: NodeConfig[Key]) { + this.configuration[key] = value; + } + + config(config: Partial) { + type NodeConfigKey = keyof NodeConfig; + + for (const key of Object.keys(config) as NodeConfigKey[]) { + const updateValue = config[key]; + + if (updateValue === undefined) { + continue; + } + + this.updateConfig(key, updateValue); + } + + return this; + } + } + + // `Partial`` allows us to provide only a part of the + // NodeConfig interface. + new NodeAppBuilder().config({appName: 'ToDoApp'}); + ``` +
+ +- [`Required`](https://www.typescriptlang.org/docs/handbook/utility-types.html#requiredtype) - Make all properties in `T` required. +
+ + Example + + + [Playground](https://typescript-play.js.org/?target=6#code/AQ4SwOwFwUwJwGYEMDGNgGED21VQGJZwC2wA3gFCjXAzFJgA2A-AFzADOUckA5gNxUaIYjA4ckvGG07c+g6gF8KQkAgCuEFFDA5O6gEbEwUbLm2ESwABQIixACJIoSdgCUYAR3Vg4MACYAPGYuFvYAfACU5Ko0APRxwADKMBD+wFAAFuh2Vv7OSBlYGdmc8ABu8LHKsRyGxqY4oQT21pTCIHQMjOwA5DAAHgACxAAOjDAAdChYxL0ANLHUouKSMH0AEmAAhJhY6ozpAJ77GTCMjMCiV0ToSAb7UJPPC9WRgrEJwAAqR6MwSRQPFGUFocDgRHYxnEfGAowh-zgUCOwF6KwkUl6tXqJhCeEsxDaS1AXSYfUGI3GUxmc0WSneQA) + + ```ts + interface ContactForm { + email?: string; + message?: string; + } + + function submitContactForm(formData: Required) { + // Send the form data to the server. + } + + submitContactForm({ + email: 'ex@mple.com', + message: 'Hi! Could you tell me more about…', + }); + + // TypeScript error: missing property 'message' + submitContactForm({ + email: 'ex@mple.com', + }); + ``` +
+ +- [`Readonly`](https://www.typescriptlang.org/docs/handbook/utility-types.html#readonlytype) - Make all properties in `T` readonly. +
+ + Example + + + [Playground](https://typescript-play.js.org/?target=6#code/AQ4UwOwVwW2AZA9gc3mAbmANsA3gKFCOAHkAzMgGkOJABEwAjKZa2kAUQCcvEu32AMQCGAF2FYBIAL4BufDRABLCKLBcywgMZgEKZOoDCiCGSXI8i4hGEwwALmABnUVxXJ57YFgzZHSVF8sT1BpBSItLGEnJz1kAy5LLy0TM2RHACUwYQATEywATwAeAITjU3MAPnkrCJMXLigtUT4AClxgGztKbyDgaX99I1TzAEokr1BRAAslJwA6FIqLAF48TtswHp9MHDla9hJGACswZvmyLjAwAC8wVpm5xZHkUZDaMKIwqyWXYCW0oN4sNlsA1h0ug5gAByACyBQAggAHJHQ7ZBIFoXbzBjMCz7OoQP5YIaJNYQMAAdziCVaALGNSIAHomcAACoFJFgADKWjcSNEwG4vC4ji0wggEEQguiTnMEGALWAV1yAFp8gVgEjeFyuKICvMrCTgVxnst5jtsGC4ljsPNhXxGaAWcAAOq6YRXYDCRg+RWIcA5JSC+kWdCepQ+v3RYCU3RInzRMCGwlpC19NYBW1Ye08R1AA) + + ```ts + enum LogLevel { + Off, + Debug, + Error, + Fatal + }; + + interface LoggerConfig { + name: string; + level: LogLevel; + } + + class Logger { + config: Readonly; + + constructor({name, level}: LoggerConfig) { + this.config = {name, level}; + Object.freeze(this.config); + } + } + + const config: LoggerConfig = { + name: 'MyApp', + level: LogLevel.Debug + }; + + const logger = new Logger(config); + + // TypeScript Error: cannot assign to read-only property. + logger.config.level = LogLevel.Error; + + // We are able to edit config variable as we please. + config.level = LogLevel.Error; + ``` +
+ +- [`Pick`](https://www.typescriptlang.org/docs/handbook/utility-types.html#picktype-keys) - From `T`, pick a set of properties whose keys are in the union `K`. +
+ + Example + + + [Playground](https://typescript-play.js.org/?target=6#code/AQ4SwOwFwUwJwGYEMDGNgEE5TCgNugN4BQoZwOUBAXMAM5RyQDmA3KeSFABYCuAtgCMISMHloMmENh04oA9tBjQJjFuzIBfYrOAB6PcADCcGElh1gEGAHcKATwAO6ebyjB5CTNlwFwSxFR0BX5HeToYABNgBDh5fm8cfBg6AHIKG3ldA2BHOOcfFNpUygJ0pAhokr4hETFUgDpswywkggAFUwA3MFtgAF5gQgowKhhVKTYKGuFRcXo1aVZgbTIoJ3RW3xhOmB6+wfbcAGsAHi3kgBpgEtGy4AAfG54BWfqAPnZm4AAlZUj4MAkMA8GAGB4vEgfMlLLw6CwPBA8PYRmMgZVgAC6CgmI4cIommQELwICh8RBgKZKvALh1ur0bHQABR5PYMui0Wk7em2ADaAF0AJS0AASABUALIAGQAogR+Mp3CROCAFBBwVC2ikBpj5CgBIqGjizLA5TAFdAmalImAuqlBRoVQh5HBgEy1eDWfs7J5cjzGYKhroVfpDEhHM4MV6GRR5NN0JrtnRg6BVirTFBeHAKYmYY6QNpdB73LmCJZBlSAXAubtvczeSmQMNSuMbmKNgBlHFgPEUNwusBIPAAQlS1xetTmxT0SDoESgdD0C4aACtHMwxytLrohawgA) + + ```ts + interface Article { + title: string; + thumbnail: string; + content: string; + } + + // Creates new type out of the `Article` interface composed + // from the Articles' two properties: `title` and `thumbnail`. + // `ArticlePreview = {title: string; thumbnail: string}` + type ArticlePreview = Pick; + + // Render a list of articles using only title and description. + function renderArticlePreviews(previews: ArticlePreview[]): HTMLElement { + const articles = document.createElement('div'); + + for (const preview of previews) { + // Append preview to the articles. + } + + return articles; + } + + const articles = renderArticlePreviews([ + { + title: 'TypeScript tutorial!', + thumbnail: '/assets/ts.jpg' + } + ]); + ``` +
+ +- [`Record`](https://www.typescriptlang.org/docs/handbook/utility-types.html#recordkeys-type) - Construct a type with a set of properties `K` of type `T`. +
+ + Example + + + [Playground](https://typescript-play.js.org/?target=6#code/AQ4ejYAUHsGcCWAXBMB2dgwGbAKYC2ADgDYwCeeemCaWArgE7ADGMxAhmuQHQBQoYEnJE8wALKEARnkaxEKdMAC8wAOS0kstGuAAfdQBM8ANzxlRjXQbVaWACwC0JPB0NqA3HwGgIwAJJoWozYHCxixnAsjAhStADmwESMMJYo1Fi4HMCIaPEu+MRklHj8gpqyoeHAAKJFFFTAAN4+giDYCIxwSAByHAR4AFw5SDF5Xm2gJBzdfQPD3WPxE5PAlBxdAPLYNQAelgh4aOHDaPQEMowrIAC+3oJ+AMKMrlrAXFhSAFZ4LEhC9g4-0BmA4JBISXgiCkBQABpILrJ5MhUGhYcATGD6Bk4Hh-jNgABrPDkOBlXyQAAq9ngYmJpOAAHcEOCRjAXqwYODfoo6DhakUSph+Uh7GI4P0xER4Cj0OSQGwMP8tP1hgAlX7swwAHgRl2RvIANALSA08ABtAC6AD4VM1Wm0Kow0MMrYaHYJjGYLLJXZb3at1HYnC43Go-QHQDcvA6-JsmEJXARgCDgMYWAhjIYhDAU+YiMAAFIwex0ZmilMITCGF79TLAGRsAgJYAAZRwSEZGzEABFTOZUrJ5Yn+jwnWgeER6HB7AAKJrADpdXqS4ZqYultTG6azVfqHswPBbtauLY7fayQ7HIbAAAMwBuAEoYw9IBq2Ixs9h2eFMOQYPQObALQKJgggABeYhghCIpikkKRpOQRIknAsZUiIeCttECBEP8NSMCkjDDAARMGziuIYxHwYOjDCMBmDNnAuTxA6irdCOBB1Lh5Dqpqn66tISIykawBnOCtqqC0gbjqc9DgpGkxegOliyfJDrRkAA) + + ```ts + // Positions of employees in our company. + type MemberPosition = 'intern' | 'developer' | 'tech-lead'; + + // Interface describing properties of a single employee. + interface Employee { + firstName: string; + lastName: string; + yearsOfExperience: number; + } + + // Create an object that has all possible `MemberPosition` values set as keys. + // Those keys will store a collection of Employees of the same position. + const team: Record = { + intern: [], + developer: [], + 'tech-lead': [], + }; + + // Our team has decided to help John with his dream of becoming Software Developer. + team.intern.push({ + firstName: 'John', + lastName: 'Doe', + yearsOfExperience: 0 + }); + + // `Record` forces you to initialize all of the property keys. + // TypeScript Error: "tech-lead" property is missing + const teamEmpty: Record = { + intern: null, + developer: null, + }; + ``` +
+ +- [`Exclude`](https://www.typescriptlang.org/docs/handbook/utility-types.html#excludetype-excludedunion) - Exclude from `T` those types that are assignable to `U`. +
+ + Example + + + [Playground](https://typescript-play.js.org/?target=6#code/JYOwLgpgTgZghgYwgAgMrQG7QMIHsQzADmyA3gFDLIAOuUYAXMiAK4A2byAPsgM5hRQJHqwC2AI2gBucgF9y5MAE9qKAEoQAjiwj8AEnBAATNtGQBeZAAooWphu26wAGmS3e93bRC8IASgsAPmRDJRlyAHoI5ABRAA8ENhYjFFYOZGVVZBgoXFFkAAM0zh5+QRBhZhYJaAKAOkjogEkQZAQ4X2QAdwALCFbaemRgXmQtFjhOMFwq9K6ULuB0lk6U+HYwZAxJnQaYFhAEMGB8ZCIIMAAFOjAANR2IK0HGWISklIAedCgsKDwCYgAbQA5M9gQBdVzFQJ+JhiSRQMiUYYwayZCC4VHPCzmSzAspCYEBWxgFhQAZwKC+FpgJ43VwARgADH4ZFQSWSBjcZPJyPtDsdTvxKWBvr8rD1DCZoJ5HPopaYoK4EPhCEQmGKcKriLCtrhgEYkVQVT5Nr4fmZLLZtMBbFZgT0wGBqES6ghbHBIJqoBKFdBWQpjfh+DQbhY2tqiHVsbjLMVkAB+ZAAZiZaeQTHOVxu9ySjxNaujNwDVHNvzqbBGkBAdPoAfkQA) + + ```ts + interface ServerConfig { + port: null | string | number; + } + + type RequestHandler = (request: Request, response: Response) => void; + + // Exclude `null` type from `null | string | number`. + // In case the port is equal to `null`, we will use default value. + function getPortValue(port: Exclude): number { + if (typeof port === 'string') { + return parseInt(port, 10); + } + + return port; + } + + function startServer(handler: RequestHandler, config: ServerConfig): void { + const server = require('http').createServer(handler); + + const port = config.port === null ? 3000 : getPortValue(config.port); + server.listen(port); + } + ``` +
+ +- [`Extract`](https://www.typescriptlang.org/docs/handbook/utility-types.html#extracttype-union) - Extract from `T` those types that are assignable to `U`. +
+ + Example + + + [Playground](https://typescript-play.js.org/?target=6#code/CYUwxgNghgTiAEAzArgOzAFwJYHtXzSwEdkQBJYACgEoAueVZAWwCMQYBuAKDDwGcM8MgBF4AXngBlAJ6scESgHIRi6ty5ZUGdoihgEABXZ888AN5d48ANoiAuvUat23K6ihMQ9ATE0BzV3goPy8GZjZOLgBfLi4Aejj4AEEICBwAdz54MAALKFQQ+BxEeAAHY1NgKAwoIKy0grr4DByEUpgccpgMaXgAaxBerCzi+B9-ZulygDouFHRsU1z8kKMYE1RhaqgAHkt4AHkWACt4EAAPbVRgLLWNgBp9gGlBs8uQa6yAUUuYPQwdgNpKM7nh7mMML4CgA+R5WABqUAgpDeVxuhxO1he0jsXGh8EoOBO9COx3BQPo2PBADckaR6IjkSA6PBqTgsMBzPsicdrEC7OJWXSQNwYvFEgAVTS9JLXODpeDpKBZFg4GCoWa8VACIJykAKiQWKy2YQOAioYikCg0OEMDyhRSy4DyxS24KhAAMjyi6gS8AAwjh5OD0iBFHAkJoEOksC1mnkMJq8gUQKDNttKPlnfrwYp3J5XfBHXqoKpfYkAOI4ansTxaeDADmoRSCCBYAbxhC6TDx6rwYHIRX5bScjA4bLJwoDmDwDkfbA9JMrVMVdM1TN69LgkTgwgkchUahqIA) + + ```ts + declare function uniqueId(): number; + + const ID = Symbol('ID'); + + interface Person { + [ID]: number; + name: string; + age: number; + } + + // Allows changing the person data as long as the property key is of string type. + function changePersonData< + Obj extends Person, + Key extends Extract, + Value extends Obj[Key] + > (obj: Obj, key: Key, value: Value): void { + obj[key] = value; + } + + // Tiny Andrew was born. + const andrew = { + [ID]: uniqueId(), + name: 'Andrew', + age: 0, + }; + + // Cool, we're fine with that. + changePersonData(andrew, 'name', 'Pony'); + + // Goverment didn't like the fact that you wanted to change your identity. + changePersonData(andrew, ID, uniqueId()); + ``` +
+ +- [`NonNullable`](https://www.typescriptlang.org/docs/handbook/utility-types.html#nonnullabletype) - Exclude `null` and `undefined` from `T`. +
+ + Example + + Works with strictNullChecks set to true. + + [Playground](https://typescript-play.js.org/?target=6#code/C4TwDgpgBACg9gJ2AOQK4FsBGEFQLxQDOwCAlgHYDmUAPlORtrnQwDasDcAUFwPQBU-WAEMkUOADMowqAGNWwwoSgATCBIqlgpOOSjAAFsOBRSy1IQgr9cKJlSlW1mZYQA3HFH68u8xcoBlHA8EACEHJ08Aby4oKDBUTFZSWXjEFEYcAEIALihkXTR2YSSIAB54JDQsHAA+blj4xOTUsHSACkMzPKD3HHDHNQQAGjSkPMqMmoQASh7g-oihqBi4uNIpdraxPAI2VhmVxrX9AzMAOm2ppnwoAA4ABifuE4BfKAhWSyOTuK7CS7pao3AhXF5rV48E4ICDAVAIPT-cGQyG+XTEIgLMJLTx7CAAdygvRCA0iCHaMwarhJOIQjUBSHaACJHk8mYdeLwxtdcVAAOSsh58+lXdr7Dlcq7A3n3J4PEUdADMcspUE53OluAIUGVTx46oAKuAIAFZGQwCYAKIIBCILjUxaDHAMnla+iodjcIA) + + ```ts + type PortNumber = string | number | null; + + /** Part of a class definition that is used to build a server */ + class ServerBuilder { + portNumber!: NonNullable; + + port(this: ServerBuilder, port: PortNumber): ServerBuilder { + if (port == null) { + this.portNumber = 8000; + } else { + this.portNumber = port; + } + + return this; + } + } + + const serverBuilder = new ServerBuilder(); + + serverBuilder + .port('8000') // portNumber = '8000' + .port(null) // portNumber = 8000 + .port(3000); // portNumber = 3000 + + // TypeScript error + serverBuilder.portNumber = null; + ``` +
+ +- [`Parameters`](https://www.typescriptlang.org/docs/handbook/utility-types.html#parameterstype) - Obtain the parameters of a function type in a tuple. +
+ + Example + + + [Playground](https://typescript-play.js.org/?target=6#code/GYVwdgxgLglg9mABAZwBYmMANgUwBQxgAOIUAXIgIZgCeA2gLoCUFAbnDACaIDeAUIkQB6IYgCypSlBxUATrMo1ECsJzgBbLEoipqAc0J7EMKMgDkiHLnU4wp46pwAPHMgB0fAL58+oSLARECEosLAA5ABUYG2QAHgAxJGdpVWREPDdMylk9ZApqemZEAF4APipacrw-CApEgBogkKwAYThwckQwEHUAIxxZJl4BYVEImiIZKF0oZRwiWVdbeygJmThgOYgcGFYcbhqApCJsyhtpWXcR1cnEePBoeDAABVPzgbTixFeFd8uEsClADcIxGiygIFkSEOT3SmTc2VydQeRx+ZxwF2QQ34gkEwDgsnSuFmMBKiAADEDjIhYk1Qm0OlSYABqZnYka4xA1DJZHJYkGc7yCbyeRA+CAIZCzNAYbA4CIAdxg2zJwVCkWirjwMswuEaACYmCCgA) + + ```ts + function shuffle(input: any[]): void { + // Mutate array randomly changing its' elements indexes. + } + + function callNTimes any> (func: Fn, callCount: number) { + // Type that represents the type of the received function parameters. + type FunctionParameters = Parameters; + + return function (...args: FunctionParameters) { + for (let i = 0; i < callCount; i++) { + func(...args); + } + } + } + + const shuffleTwice = callNTimes(shuffle, 2); + ``` +
+ +- [`ConstructorParameters`](https://www.typescriptlang.org/docs/handbook/utility-types.html#constructorparameterstype) - Obtain the parameters of a constructor function type in a tuple. +
+ + Example + + + [Playground](https://typescript-play.js.org/?target=6#code/MYGwhgzhAECCBOAXAlqApgWQPYBM0mgG8AoaaFRENALmgkXmQDsBzAblOmCycTV4D8teo1YdO3JiICuwRFngAKClWENmLAJRFOZRAAtkEAHQq00ALzlklNBzIBfYk+KhIMAJJTEYJsDQAwmDA+mgAPAAq0GgAHnxMODCKTGgA7tCKxllg8CwQtL4AngDaALraFgB80EWa1SRkAA6MAG5gfNAB4FABPDJyCrQR9tDNyG0dwMGhtBhgjWEiGgA00F70vv4RhY3hEZXVVinpc42KmuJkkv3y8Bly8EPaDWTkhiZd7r3e8LK3llwGCMXGQWGhEOsfH5zJlsrl8p0+gw-goAAo5MAAW3BaHgEEilU0tEhmzQ212BJ0ry4SOg+kg+gBBiMximIGA0nAfAQLGk2N4EAAEgzYcYcnkLsRdDTvNEYkYUKwSdCme9WdM0MYwYhFPSIPpJdTkAAzDKxBUaZX+aAAQgsVmkCTQxuYaBw2ng4Ok8CYcotSu8pMur09iG9vuObxZnx6SN+AyUWTF8MN0CcZE4Ywm5jZHK5aB5fP4iCFIqT4oRRTKRLo6lYVNeAHpG50wOzOe1zHr9NLQ+HoABybsD4HOKXXRA1JCoKhBELmI5pNaB6Fz0KKBAodDYPAgSUTmqYsAALx4m5nC6nW9nGq14KtaEUA9gR9PvuNCjQ9BgACNvcwNBtAcLiAA) + + ```ts + class ArticleModel { + title: string; + content?: string; + + constructor(title: string) { + this.title = title; + } + } + + class InstanceCache any)> { + private ClassConstructor: T; + private cache: Map> = new Map(); + + constructor (ctr: T) { + this.ClassConstructor = ctr; + } + + getInstance (...args: ConstructorParameters): InstanceType { + const hash = this.calculateArgumentsHash(...args); + + const existingInstance = this.cache.get(hash); + if (existingInstance !== undefined) { + return existingInstance; + } + + return new this.ClassConstructor(...args); + } + + private calculateArgumentsHash(...args: any[]): string { + // Calculate hash. + return 'hash'; + } + } + + const articleCache = new InstanceCache(ArticleModel); + const amazonArticle = articleCache.getInstance('Amazon forests burining!'); + ``` +
+ +- [`ReturnType`](https://www.typescriptlang.org/docs/handbook/utility-types.html#returntypetype) - Obtain the return type of a function type. +
+ + Example + + + [Playground](https://typescript-play.js.org/?target=6#code/MYGwhgzhAECSAmICmBlJAnAbgS2E6A3gFDTTwD2AcuQC4AW2AdgOYAUAlAFzSbnbyEAvkWFFQkGJSQB3GMVI1sNZNwg10TZgG4S0YOUY0kh1es07d+xmvQBXYDXLpWi5UlMaWAGj0GjJ6BtNdkJdBQYIADpXZGgAXmgYpB1ScOwoq38aeN9DYxoU6GFRKzVoJjUwRjwAYXJbPPRuAFkwAAcAHgAxBodsAx9GWwBbACMMAD4cxhloVraOCyYjdAAzMDxoOut1e0d0UNIZ6WhWSPOwdGYIbiqATwBtAF0uaHudUQB6ACpv6ABpJBINqJdAbADW0Do5BOw3u5R2VTwMHIq2gAANtjZ0bkbHsnFCwJh8ONjHp0EgwEZ4JFoN9PkRVr1FAZoMwkDRYIjqkgOrosepoEgAB7+eAwAV2BxOLy6ACCVxgIrFEoMeOl6AACpcwMMORgIB1JRMiBNWKVdhruJKfOdIpdrtwFddXlzKjyACp3Nq842HaDIbL6BrZBIVGhIpB1EMYSLsmjmtWW-YhAA+qegAAYLKQLQj3ZsEsdccmnGcLor2Dn8xGedHGpEIBzEzspfsfMHDNAANTQACMVaIljV5GQkRA5DYmIpVKQAgAJARO9le33BDXIyi0YuLW2nJFGLqkOvxFB0YPdBSaLZ0IwNzyPkO8-xkGgsLh8Al427a3hWAhXwwHA8EHT5PmgAB1bAQBAANJ24adKWpft72RaBUTgRBUCAj89HAM8xCTaBjggABRQx0DuHJv25P9dCkWRZVIAAiBjoFImpmjlFBgA0NpsjadByDacgIDAEAIAAQmYpjoGYgAZSBsmGPw6DtZiiFA8CoJguDmAQmoZ2QvtUKQLdoAYmBTwgdEiCAA) + + ```ts + /** Provides every element of the iterable `iter` into the `callback` function and stores the results in an array. */ + function mapIter< + Elem, + Func extends (elem: Elem) => any, + Ret extends ReturnType + >(iter: Iterable, callback: Func): Ret[] { + const mapped: Ret[] = []; + + for (const elem of iter) { + mapped.push(callback(elem)); + } + + return mapped; + } + + const setObject: Set = new Set(); + const mapObject: Map = new Map(); + + mapIter(setObject, (value: string) => value.indexOf('Foo')); // number[] + + mapIter(mapObject, ([key, value]: [number, string]) => { + return key % 2 === 0 ? value : 'Odd'; + }); // string[] + ``` +
+ +- [`InstanceType`](https://www.typescriptlang.org/docs/handbook/utility-types.html#instancetypetype) - Obtain the instance type of a constructor function type. +
+ + Example + + + [Playground](https://typescript-play.js.org/?target=6#code/MYGwhgzhAECSAmICmBlJAnAbgS2E6A3gFDTTwD2AcuQC4AW2AdgOYAUAlAFzSbnbyEAvkWFFQkGJSQB3GMVI1sNZNwg10TZgG4S0YOUY0kh1es07d+xmvQBXYDXLpWi5UlMaWAGj0GjJ6BtNdkJdBQYIADpXZGgAXmgYpB1ScOwoq38aeN9DYxoU6GFRKzVoJjUwRjwAYXJbPPRuAFkwAAcAHgAxBodsAx9GWwBbACMMAD4cxhloVraOCyYjdAAzMDxoOut1e0d0UNIZ6WhWSPOwdGYIbiqATwBtAF0uaHudUQB6ACpv6ABpJBINqJdAbADW0Do5BOw3u5R2VTwMHIq2gAANtjZ0bkbHsnFCwJh8ONjHp0EgwEZ4JFoN9PkRVr1FAZoMwkDRYIjqkgOrosepoEgAB7+eAwAV2BxOLy6ACCVxgIrFEoMeOl6AACpcwMMORgIB1JRMiBNWKVdhruJKfOdIpdrtwFddXlzKjyACp3Nq842HaDIbL6BrZBIVGhIpB1EMYSLsmjmtWW-YhAA+qegAAYLKQLQj3ZsEsdccmnGcLor2Dn8xGedHGpEIBzEzspfsfMHDNAANTQACMVaIljV5GQkRA5DYmIpVKQAgAJARO9le33BDXIyi0YuLW2nJFGLqkOvxFB0YPdBSaLZ0IwNzyPkO8-xkGgsLh8Al427a3hWAhXwwHA8EHT5PmgAB1bAQBAANJ24adKWpft72RaBUTgRBUCAj89HAM8xCTaBjggABRQx0DuHJv25P9dCkWRZVIAAiBjoFImpmjlFBgA0NpsjadByDacgIDAEAIAAQmYpjoGYgAZSBsmGPw6DtZiiFA8CoJguDmAQmoZ2QvtUKQLdoAYmBTwgdEiCAA) + + ```ts + class IdleService { + doNothing (): void {} + } + + class News { + title: string; + content: string; + + constructor(title: string, content: string) { + this.title = title; + this.content = content; + } + } + + const instanceCounter: Map = new Map(); + + interface Constructor { + new(...args: any[]): any; + } + + // Keep track how many instances of `Constr` constructor have been created. + function getInstance< + Constr extends Constructor, + Args extends ConstructorParameters + >(constructor: Constr, ...args: Args): InstanceType { + let count = instanceCounter.get(constructor) || 0; + + const instance = new constructor(...args); + + instanceCounter.set(constructor, count + 1); + + console.log(`Created ${count + 1} instances of ${Constr.name} class`); + + return instance; + } + + + const idleService = getInstance(IdleService); + // Will log: `Created 1 instances of IdleService class` + const newsEntry = getInstance(News, 'New ECMAScript proposals!', 'Last month...'); + // Will log: `Created 1 instances of News class` + ``` +
+ +- [`Omit`](https://www.typescriptlang.org/docs/handbook/utility-types.html#omittype-keys) - Constructs a type by picking all properties from T and then removing K. +
+ + Example + + + [Playground](https://typescript-play.js.org/?target=6#code/JYOwLgpgTgZghgYwgAgIImAWzgG2QbwChlks4BzCAVShwC5kBnMKUcgbmKYAcIFgIjBs1YgOXMpSFMWbANoBdTiW5woFddwAW0kfKWEAvoUIB6U8gDCUCHEiNkICAHdkYAJ69kz4GC3JcPG4oAHteKDABBxCYNAxsPFBIWEQUCAAPJG4wZABySUFcgJAAEzMLXNV1ck0dIuCw6EjBADpy5AB1FAQ4EGQAV0YUP2AHDy8wEOQbUugmBLwtEIA3OcmQnEjuZBgQqE7gAGtgZAhwKHdkHFGwNvGUdDIcAGUliIBJEF3kAF5kAHlML4ADyPBIAGjyBUYRQAPnkqho4NoYQA+TiEGD9EAISIhPozErQMG4AASK2gn2+AApek9pCSXm8wFSQooAJQMUkAFQAsgAZACiOAgmDOOSIJAQ+OYyGl4DgoDmf2QJRCCH6YvALQQNjsEGFovF1NyJWAy1y7OUyHMyE+yRAuFImG4Iq1YDswHxbRINjA-SgfXlHqVUE4xiAA) + + ```ts + interface Animal { + imageUrl: string; + species: string; + images: string[]; + paragraphs: string[]; + } + + // Creates new type with all properties of the `Animal` interface + // except 'images' and 'paragraphs' properties. We can use this + // type to render small hover tooltip for a wiki entry list. + type AnimalShortInfo = Omit; + + function renderAnimalHoverInfo (animals: AnimalShortInfo[]): HTMLElement { + const container = document.createElement('div'); + // Internal implementation. + return container; + } + ``` +
+ +- [`Uppercase`](https://www.typescriptlang.org/docs/handbook/utility-types.html#uppercasestringtype) - Transforms every character in a string into uppercase. +
+ + Example + + + ```ts + type T = Uppercase<'hello'>; // 'HELLO' + + type T2 = Uppercase<'foo' | 'bar'>; // 'FOO' | 'BAR' + + type T3 = Uppercase<`aB${S}`>; + type T4 = T3<'xYz'>; // 'ABXYZ' + + type T5 = Uppercase; // string + type T6 = Uppercase; // any + type T7 = Uppercase; // never + type T8 = Uppercase<42>; // Error, type 'number' does not satisfy the constraint 'string' + ``` +
+ +- [`Lowercase`](https://www.typescriptlang.org/docs/handbook/utility-types.html#lowercasestringtype) - Transforms every character in a string into lowercase. +
+ + Example + + + ```ts + type T = Lowercase<'HELLO'>; // 'hello' + + type T2 = Lowercase<'FOO' | 'BAR'>; // 'foo' | 'bar' + + type T3 = Lowercase<`aB${S}`>; + type T4 = T3<'xYz'>; // 'abxyz' + + type T5 = Lowercase; // string + type T6 = Lowercase; // any + type T7 = Lowercase; // never + type T8 = Lowercase<42>; // Error, type 'number' does not satisfy the constraint 'string' + ``` +
+ +- [`Capitalize`](https://www.typescriptlang.org/docs/handbook/utility-types.html#capitalizestringtype) - Transforms the first character in a string into uppercase. +
+ + Example + + + ```ts + type T = Capitalize<'hello'>; // 'Hello' + + type T2 = Capitalize<'foo' | 'bar'>; // 'Foo' | 'Bar' + + type T3 = Capitalize<`aB${S}`>; + type T4 = T3<'xYz'>; // 'ABxYz' + + type T5 = Capitalize; // string + type T6 = Capitalize; // any + type T7 = Capitalize; // never + type T8 = Capitalize<42>; // Error, type 'number' does not satisfy the constraint 'string' + ``` +
+ +- [`Uncapitalize`](https://www.typescriptlang.org/docs/handbook/utility-types.html#uncapitalizestringtype) - Transforms the first character in a string into lowercase. +
+ + Example + + + ```ts + type T = Uncapitalize<'Hello'>; // 'hello' + + type T2 = Uncapitalize<'Foo' | 'Bar'>; // 'foo' | 'bar' + + type T3 = Uncapitalize<`AB${S}`>; + type T4 = T3<'xYz'>; // 'aBxYz' + + type T5 = Uncapitalize; // string + type T6 = Uncapitalize; // any + type T7 = Uncapitalize; // never + type T8 = Uncapitalize<42>; // Error, type 'number' does not satisfy the constraint 'string' + ``` +
+ +You can find some examples in the [TypeScript docs](https://www.typescriptlang.org/docs/handbook/utility-types.html). + +## Maintainers + +- [Sindre Sorhus](https://github.com/sindresorhus) +- [Jarek Radosz](https://github.com/CvX) +- [Dimitri Benin](https://github.com/BendingBender) +- [Pelle Wessman](https://github.com/voxpelli) + +## License + +SPDX-License-Identifier: (MIT OR CC0-1.0) + +--- + +
+ + Get professional support for this package with a Tidelift subscription + +
+ + Tidelift helps make open source sustainable for maintainers while giving companies
assurances about security, maintenance, and licensing for their dependencies. + +
diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/async-return-type.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/async-return-type.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..57cc36314ed00e12af86c251614c357b97a5d54a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/async-return-type.d.ts @@ -0,0 +1,25 @@ +import type {PromiseValue} from './promise-value'; + +type AsyncFunction = (...args: any[]) => Promise; + +/** +Unwrap the return type of a function that returns a `Promise`. + +There has been [discussion](https://github.com/microsoft/TypeScript/pull/35998) about implementing this type in TypeScript. + +@example +```ts +import type {AsyncReturnType} from 'type-fest'; +import {asyncFunction} from 'api'; + +// This type resolves to the unwrapped return type of `asyncFunction`. +type Value = AsyncReturnType; + +async function doSomething(value: Value) {} + +asyncFunction().then(value => doSomething(value)); +``` + +@category Async +*/ +export type AsyncReturnType = PromiseValue>; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/asyncify.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/asyncify.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6726b7e151f735fbc146f47f38f177427b8df208 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/asyncify.d.ts @@ -0,0 +1,33 @@ +import type {PromiseValue} from './promise-value'; +import type {SetReturnType} from './set-return-type'; + +/** +Create an async version of the given function type, by boxing the return type in `Promise` while keeping the same parameter types. + +Use-case: You have two functions, one synchronous and one asynchronous that do the same thing. Instead of having to duplicate the type definition, you can use `Asyncify` to reuse the synchronous type. + +@example +``` +import type {Asyncify} from 'type-fest'; + +// Synchronous function. +function getFooSync(someArg: SomeType): Foo { + // … +} + +type AsyncifiedFooGetter = Asyncify; +//=> type AsyncifiedFooGetter = (someArg: SomeType) => Promise; + +// Same as `getFooSync` but asynchronous. +const getFooAsync: AsyncifiedFooGetter = (someArg) => { + // TypeScript now knows that `someArg` is `SomeType` automatically. + // It also knows that this function must return `Promise`. + // If you have `@typescript-eslint/promise-function-async` linter rule enabled, it will even report that "Functions that return promises must be async.". + + // … +} +``` + +@category Async +*/ +export type Asyncify any> = SetReturnType>>>; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/basic.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/basic.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ac74fdc9a93374f329a584b55d8c09e6ba80159e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/basic.d.ts @@ -0,0 +1,45 @@ +/** +Matches a [`class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes). + +@category Class +*/ +export type Class = Constructor & {prototype: T}; + +/** +Matches a [`class` constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes). + +@category Class +*/ +export type Constructor = new(...arguments_: Arguments) => T; + +/** +Matches a JSON object. + +This type can be useful to enforce some input to be JSON-compatible or as a super-type to be extended from. Don't use this as a direct return type as the user would have to double-cast it: `jsonObject as unknown as CustomResponse`. Instead, you could extend your CustomResponse type from it to ensure your type only uses JSON-compatible types: `interface CustomResponse extends JsonObject { … }`. + +@category JSON +*/ +export type JsonObject = {[Key in string]?: JsonValue}; + +/** +Matches a JSON array. + +@category JSON +*/ +export type JsonArray = JsonValue[]; + +/** +Matches any valid JSON primitive value. + +@category JSON +*/ +export type JsonPrimitive = string | number | boolean | null; + +/** +Matches any valid JSON value. + +@see `Jsonify` if you need to transform a type to one that is assignable to `JsonValue`. + +@category JSON +*/ +export type JsonValue = JsonPrimitive | JsonObject | JsonArray; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/camel-case.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/camel-case.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..bcf54fc9d6e8a6118901023b2e95fcf96151c708 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/camel-case.d.ts @@ -0,0 +1,73 @@ +import type {WordSeparators} from '../source/internal'; +import type {Split} from './split'; + +/** +Step by step takes the first item in an array literal, formats it and adds it to a string literal, and then recursively appends the remainder. + +Only to be used by `CamelCaseStringArray<>`. + +@see CamelCaseStringArray +*/ +type InnerCamelCaseStringArray = + Parts extends [`${infer FirstPart}`, ...infer RemainingParts] + ? FirstPart extends undefined + ? '' + : FirstPart extends '' + ? InnerCamelCaseStringArray + : `${PreviousPart extends '' ? FirstPart : Capitalize}${InnerCamelCaseStringArray}` + : ''; + +/** +Starts fusing the output of `Split<>`, an array literal of strings, into a camel-cased string literal. + +It's separate from `InnerCamelCaseStringArray<>` to keep a clean API outwards to the rest of the code. + +@see Split +*/ +type CamelCaseStringArray = + Parts extends [`${infer FirstPart}`, ...infer RemainingParts] + ? Uncapitalize<`${FirstPart}${InnerCamelCaseStringArray}`> + : never; + +/** +Convert a string literal to camel-case. + +This can be useful when, for example, converting some kebab-cased command-line flags or a snake-cased database result. + +@example +``` +import type {CamelCase} from 'type-fest'; + +// Simple + +const someVariable: CamelCase<'foo-bar'> = 'fooBar'; + +// Advanced + +type CamelCasedProperties = { + [K in keyof T as CamelCase]: T[K] +}; + +interface RawOptions { + 'dry-run': boolean; + 'full_family_name': string; + foo: number; + BAR: string; + QUZ_QUX: number; + 'OTHER-FIELD': boolean; +} + +const dbResult: CamelCasedProperties = { + dryRun: true, + fullFamilyName: 'bar.js', + foo: 123, + bar: 'foo', + quzQux: 6, + otherField: false +}; +``` + +@category Change case +@category Template literal +*/ +export type CamelCase = K extends string ? CamelCaseStringArray ? Lowercase : K, WordSeparators>> : K; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/camel-cased-properties-deep.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/camel-cased-properties-deep.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c821dc46b5f9a718556d71aac903b9146d6afab1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/camel-cased-properties-deep.d.ts @@ -0,0 +1,54 @@ +import type {CamelCase} from './camel-case'; + +/** +Convert object properties to camel case recursively. + +This can be useful when, for example, converting some API types from a different style. + +@see CamelCasedProperties +@see CamelCase + +@example +``` +import type {CamelCasedPropertiesDeep} from 'type-fest'; + +interface User { + UserId: number; + UserName: string; +} + +interface UserWithFriends { + UserInfo: User; + UserFriends: User[]; +} + +const result: CamelCasedPropertiesDeep = { + userInfo: { + userId: 1, + userName: 'Tom', + }, + userFriends: [ + { + userId: 2, + userName: 'Jerry', + }, + { + userId: 3, + userName: 'Spike', + }, + ], +}; +``` + +@category Change case +@category Template literal +@category Object +*/ +export type CamelCasedPropertiesDeep = Value extends Function + ? Value + : Value extends Array + ? Array> + : Value extends Set + ? Set> : { + [K in keyof Value as CamelCase]: CamelCasedPropertiesDeep; + }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/camel-cased-properties.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/camel-cased-properties.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..afe0629e99efc47f00ba46ba63f85b6f5ecd5324 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/camel-cased-properties.d.ts @@ -0,0 +1,36 @@ +import type {CamelCase} from './camel-case'; + +/** +Convert object properties to camel case but not recursively. + +This can be useful when, for example, converting some API types from a different style. + +@see CamelCasedPropertiesDeep +@see CamelCase + +@example +``` +import type {CamelCasedProperties} from 'type-fest'; + +interface User { + UserId: number; + UserName: string; +} + +const result: CamelCasedProperties = { + userId: 1, + userName: 'Tom', +}; +``` + +@category Change case +@category Template literal +@category Object +*/ +export type CamelCasedProperties = Value extends Function + ? Value + : Value extends Array + ? Value + : { + [K in keyof Value as CamelCase]: Value[K]; + }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/conditional-except.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/conditional-except.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d61792a92f8eca4096e53c479abc3afd388f4fee --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/conditional-except.d.ts @@ -0,0 +1,45 @@ +import type {Except} from './except'; +import type {ConditionalKeys} from './conditional-keys'; + +/** +Exclude keys from a shape that matches the given `Condition`. + +This is useful when you want to create a new type with a specific set of keys from a shape. For example, you might want to exclude all the primitive properties from a class and form a new shape containing everything but the primitive properties. + +@example +``` +import type {Primitive, ConditionalExcept} from 'type-fest'; + +class Awesome { + name: string; + successes: number; + failures: bigint; + + run() {} +} + +type ExceptPrimitivesFromAwesome = ConditionalExcept; +//=> {run: () => void} +``` + +@example +``` +import type {ConditionalExcept} from 'type-fest'; + +interface Example { + a: string; + b: string | number; + c: () => void; + d: {}; +} + +type NonStringKeysOnly = ConditionalExcept; +//=> {b: string | number; c: () => void; d: {}} +``` + +@category Object +*/ +export type ConditionalExcept = Except< + Base, + ConditionalKeys +>; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/conditional-keys.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/conditional-keys.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c337dbb2c1106fd82e3733013ba8344764da27d0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/conditional-keys.d.ts @@ -0,0 +1,47 @@ +/** +Extract the keys from a type where the value type of the key extends the given `Condition`. + +Internally this is used for the `ConditionalPick` and `ConditionalExcept` types. + +@example +``` +import type {ConditionalKeys} from 'type-fest'; + +interface Example { + a: string; + b: string | number; + c?: string; + d: {}; +} + +type StringKeysOnly = ConditionalKeys; +//=> 'a' +``` + +To support partial types, make sure your `Condition` is a union of undefined (for example, `string | undefined`) as demonstrated below. + +@example +``` +import type {ConditionalKeys} from 'type-fest'; + +type StringKeysAndUndefined = ConditionalKeys; +//=> 'a' | 'c' +``` + +@category Object +*/ +export type ConditionalKeys = NonNullable< + // Wrap in `NonNullable` to strip away the `undefined` type from the produced union. + { + // Map through all the keys of the given base type. + [Key in keyof Base]: + // Pick only keys with types extending the given `Condition` type. + Base[Key] extends Condition + // Retain this key since the condition passes. + ? Key + // Discard this key since the condition fails. + : never; + + // Convert the produced object into a union type of the keys which passed the conditional test. + }[keyof Base] +>; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/conditional-pick.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/conditional-pick.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f90e399b332c8fad91a2efcc52fdc04d2e4f5ea8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/conditional-pick.d.ts @@ -0,0 +1,44 @@ +import type {ConditionalKeys} from './conditional-keys'; + +/** +Pick keys from the shape that matches the given `Condition`. + +This is useful when you want to create a new type from a specific subset of an existing type. For example, you might want to pick all the primitive properties from a class and form a new automatically derived type. + +@example +``` +import type {Primitive, ConditionalPick} from 'type-fest'; + +class Awesome { + name: string; + successes: number; + failures: bigint; + + run() {} +} + +type PickPrimitivesFromAwesome = ConditionalPick; +//=> {name: string; successes: number; failures: bigint} +``` + +@example +``` +import type {ConditionalPick} from 'type-fest'; + +interface Example { + a: string; + b: string | number; + c: () => void; + d: {}; +} + +type StringKeysOnly = ConditionalPick; +//=> {a: string} +``` + +@category Object +*/ +export type ConditionalPick = Pick< + Base, + ConditionalKeys +>; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/delimiter-case.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/delimiter-case.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..770707ef4ee48a1593f6f50ce7e6cc95167e7427 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/delimiter-case.d.ts @@ -0,0 +1,93 @@ +import type {UpperCaseCharacters, WordSeparators} from '../source/internal'; + +/** +Unlike a simpler split, this one includes the delimiter splitted on in the resulting array literal. This is to enable splitting on, for example, upper-case characters. + +@category Template literal +*/ +export type SplitIncludingDelimiters = + Source extends '' ? [] : + Source extends `${infer FirstPart}${Delimiter}${infer SecondPart}` ? + ( + Source extends `${FirstPart}${infer UsedDelimiter}${SecondPart}` + ? UsedDelimiter extends Delimiter + ? Source extends `${infer FirstPart}${UsedDelimiter}${infer SecondPart}` + ? [...SplitIncludingDelimiters, UsedDelimiter, ...SplitIncludingDelimiters] + : never + : never + : never + ) : + [Source]; + +/** +Format a specific part of the splitted string literal that `StringArrayToDelimiterCase<>` fuses together, ensuring desired casing. + +@see StringArrayToDelimiterCase +*/ +type StringPartToDelimiterCase = + StringPart extends UsedWordSeparators ? Delimiter : + Start extends true ? Lowercase : + StringPart extends UsedUpperCaseCharacters ? `${Delimiter}${Lowercase}` : + StringPart; + +/** +Takes the result of a splitted string literal and recursively concatenates it together into the desired casing. + +It receives `UsedWordSeparators` and `UsedUpperCaseCharacters` as input to ensure it's fully encapsulated. + +@see SplitIncludingDelimiters +*/ +type StringArrayToDelimiterCase = + Parts extends [`${infer FirstPart}`, ...infer RemainingParts] + ? `${StringPartToDelimiterCase}${StringArrayToDelimiterCase}` + : Parts extends [string] + ? string + : ''; + +/** +Convert a string literal to a custom string delimiter casing. + +This can be useful when, for example, converting a camel-cased object property to an oddly cased one. + +@see KebabCase +@see SnakeCase + +@example +``` +import type {DelimiterCase} from 'type-fest'; + +// Simple + +const someVariable: DelimiterCase<'fooBar', '#'> = 'foo#bar'; + +// Advanced + +type OddlyCasedProperties = { + [K in keyof T as DelimiterCase]: T[K] +}; + +interface SomeOptions { + dryRun: boolean; + includeFile: string; + foo: number; +} + +const rawCliOptions: OddlyCasedProperties = { + 'dry#run': true, + 'include#file': 'bar.js', + foo: 123 +}; +``` + +@category Change case +@category Template literal +*/ +export type DelimiterCase = Value extends string + ? StringArrayToDelimiterCase< + SplitIncludingDelimiters, + true, + WordSeparators, + UpperCaseCharacters, + Delimiter + > + : Value; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/delimiter-cased-properties-deep.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/delimiter-cased-properties-deep.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..36b4725fd572689445f95df10cb91384904d277e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/delimiter-cased-properties-deep.d.ts @@ -0,0 +1,60 @@ +import type {DelimiterCase} from './delimiter-case'; + +/** +Convert object properties to delimiter case recursively. + +This can be useful when, for example, converting some API types from a different style. + +@see DelimiterCase +@see DelimiterCasedProperties + +@example +``` +import type {DelimiterCasedPropertiesDeep} from 'type-fest'; + +interface User { + userId: number; + userName: string; +} + +interface UserWithFriends { + userInfo: User; + userFriends: User[]; +} + +const result: DelimiterCasedPropertiesDeep = { + 'user-info': { + 'user-id': 1, + 'user-name': 'Tom', + }, + 'user-friends': [ + { + 'user-id': 2, + 'user-name': 'Jerry', + }, + { + 'user-id': 3, + 'user-name': 'Spike', + }, + ], +}; +``` + +@category Change case +@category Template literal +@category Object +*/ +export type DelimiterCasedPropertiesDeep< + Value, + Delimiter extends string, +> = Value extends Function | Date | RegExp + ? Value + : Value extends Array + ? Array> + : Value extends Set + ? Set> : { + [K in keyof Value as DelimiterCase< + K, + Delimiter + >]: DelimiterCasedPropertiesDeep; + }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/delimiter-cased-properties.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/delimiter-cased-properties.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..03b76af5459f37f277d2b2af6a0780b0056b135a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/delimiter-cased-properties.d.ts @@ -0,0 +1,37 @@ +import type {DelimiterCase} from './delimiter-case'; + +/** +Convert object properties to delimiter case but not recursively. + +This can be useful when, for example, converting some API types from a different style. + +@see DelimiterCase +@see DelimiterCasedPropertiesDeep + +@example +``` +import type {DelimiterCasedProperties} from 'type-fest'; + +interface User { + userId: number; + userName: string; +} + +const result: DelimiterCasedProperties = { + 'user-id': 1, + 'user-name': 'Tom', +}; +``` + +@category Change case +@category Template literal +@category Object +*/ +export type DelimiterCasedProperties< + Value, + Delimiter extends string, +> = Value extends Function + ? Value + : Value extends Array + ? Value + : {[K in keyof Value as DelimiterCase]: Value[K]}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/entries.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/entries.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9fe2fd32a6d600ac8c5b141165c7ca873014006c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/entries.d.ts @@ -0,0 +1,62 @@ +import type {ArrayEntry, MapEntry, ObjectEntry, SetEntry} from './entry'; + +type ArrayEntries = Array>; +type MapEntries = Array>; +type ObjectEntries = Array>; +type SetEntries> = Array>; + +/** +Many collections have an `entries` method which returns an array of a given object's own enumerable string-keyed property [key, value] pairs. The `Entries` type will return the type of that collection's entries. + +For example the {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries|`Object`}, {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries|`Map`}, {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/entries|`Array`}, and {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/entries|`Set`} collections all have this method. Note that `WeakMap` and `WeakSet` do not have this method since their entries are not enumerable. + +@see `Entry` if you want to just access the type of a single entry. + +@example +``` +import type {Entries} from 'type-fest'; + +interface Example { + someKey: number; +} + +const manipulatesEntries = (examples: Entries) => examples.map(example => [ + // Does some arbitrary processing on the key (with type information available) + example[0].toUpperCase(), + + // Does some arbitrary processing on the value (with type information available) + example[1].toFixed() +]); + +const example: Example = {someKey: 1}; +const entries = Object.entries(example) as Entries; +const output = manipulatesEntries(entries); + +// Objects +const objectExample = {a: 1}; +const objectEntries: Entries = [['a', 1]]; + +// Arrays +const arrayExample = ['a', 1]; +const arrayEntries: Entries = [[0, 'a'], [1, 1]]; + +// Maps +const mapExample = new Map([['a', 1]]); +const mapEntries: Entries = [['a', 1]]; + +// Sets +const setExample = new Set(['a', 1]); +const setEntries: Entries = [['a', 'a'], [1, 1]]; +``` + +@category Object +@category Map +@category Set +@category Array +*/ +export type Entries = + BaseType extends Map ? MapEntries + : BaseType extends Set ? SetEntries + : BaseType extends readonly unknown[] ? ArrayEntries + : BaseType extends object ? ObjectEntries + : never; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/entry.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/entry.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..678b67a1b19754be94f50e1315ae525aa2a01287 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/entry.d.ts @@ -0,0 +1,65 @@ +type MapKey = BaseType extends Map ? KeyType : never; +type MapValue = BaseType extends Map ? ValueType : never; + +export type ArrayEntry = [number, BaseType[number]]; +export type MapEntry = [MapKey, MapValue]; +export type ObjectEntry = [keyof BaseType, BaseType[keyof BaseType]]; +export type SetEntry = BaseType extends Set ? [ItemType, ItemType] : never; + +/** +Many collections have an `entries` method which returns an array of a given object's own enumerable string-keyed property [key, value] pairs. The `Entry` type will return the type of that collection's entry. + +For example the {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries|`Object`}, {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries|`Map`}, {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/entries|`Array`}, and {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/entries|`Set`} collections all have this method. Note that `WeakMap` and `WeakSet` do not have this method since their entries are not enumerable. + +@see `Entries` if you want to just access the type of the array of entries (which is the return of the `.entries()` method). + +@example +``` +import type {Entry} from 'type-fest'; + +interface Example { + someKey: number; +} + +const manipulatesEntry = (example: Entry) => [ + // Does some arbitrary processing on the key (with type information available) + example[0].toUpperCase(), + + // Does some arbitrary processing on the value (with type information available) + example[1].toFixed(), +]; + +const example: Example = {someKey: 1}; +const entry = Object.entries(example)[0] as Entry; +const output = manipulatesEntry(entry); + +// Objects +const objectExample = {a: 1}; +const objectEntry: Entry = ['a', 1]; + +// Arrays +const arrayExample = ['a', 1]; +const arrayEntryString: Entry = [0, 'a']; +const arrayEntryNumber: Entry = [1, 1]; + +// Maps +const mapExample = new Map([['a', 1]]); +const mapEntry: Entry = ['a', 1]; + +// Sets +const setExample = new Set(['a', 1]); +const setEntryString: Entry = ['a', 'a']; +const setEntryNumber: Entry = [1, 1]; +``` + +@category Object +@category Map +@category Array +@category Set +*/ +export type Entry = + BaseType extends Map ? MapEntry + : BaseType extends Set ? SetEntry + : BaseType extends readonly unknown[] ? ArrayEntry + : BaseType extends object ? ObjectEntry + : never; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/exact.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/exact.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0227f3d048fee6ccf790394ab12b18b963334bfd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/exact.d.ts @@ -0,0 +1,73 @@ +import type {KeysOfUnion} from './internal'; + +/** +Extract the element of an array that also works for array union. + +Returns `never` if T is not an array. + +It creates a type-safe way to access the element type of `unknown` type. +*/ +type ArrayElement = T extends readonly unknown[] ? T[0] : never; + +/** +Extract the object field type if T is an object and K is a key of T, return `never` otherwise. + +It creates a type-safe way to access the member type of `unknown` type. +*/ +type ObjectValue = K extends keyof T ? T[K] : never; + +/** +Create a type from `ParameterType` and `InputType` and change keys exclusive to `InputType` to `never`. +- Generate a list of keys that exists in `InputType` but not in `ParameterType`. +- Mark these excess keys as `never`. +*/ +type ExactObject = {[Key in keyof ParameterType]: Exact>} + & Record>, never>; + +/** +Create a type that does not allow extra properties, meaning it only allows properties that are explicitly declared. + +This is useful for function type-guarding to reject arguments with excess properties. Due to the nature of TypeScript, it does not complain if excess properties are provided unless the provided value is an object literal. + +*Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/12936) if you want to have this type as a built-in in TypeScript.* + +@example +``` +type OnlyAcceptName = {name: string}; + +function onlyAcceptName(args: OnlyAcceptName) {} + +// TypeScript complains about excess properties when an object literal is provided. +onlyAcceptName({name: 'name', id: 1}); +//=> `id` is excess + +// TypeScript does not complain about excess properties when the provided value is a variable (not an object literal). +const invalidInput = {name: 'name', id: 1}; +onlyAcceptName(invalidInput); // No errors +``` + +Having `Exact` allows TypeScript to reject excess properties. + +@example +``` +import {Exact} from 'type-fest'; + +type OnlyAcceptName = {name: string}; + +function onlyAcceptNameImproved>(args: T) {} + +const invalidInput = {name: 'name', id: 1}; +onlyAcceptNameImproved(invalidInput); // Compilation error +``` + +[Read more](https://stackoverflow.com/questions/49580725/is-it-possible-to-restrict-typescript-object-to-contain-only-properties-defined) + +@category Utilities +*/ +export type Exact = + // Convert union of array to array of union: A[] & B[] => (A & B)[] + ParameterType extends unknown[] ? Array, ArrayElement>> + // In TypeScript, Array is a subtype of ReadonlyArray, so always test Array before ReadonlyArray. + : ParameterType extends readonly unknown[] ? ReadonlyArray, ArrayElement>> + : ParameterType extends object ? ExactObject + : ParameterType; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/except.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/except.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..dab21d54c1ef9998ceaa0367f980591de17053b6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/except.d.ts @@ -0,0 +1,57 @@ +import type {IsEqual} from './internal'; + +/** +Filter out keys from an object. + +Returns `never` if `Exclude` is strictly equal to `Key`. +Returns `never` if `Key` extends `Exclude`. +Returns `Key` otherwise. + +@example +``` +type Filtered = Filter<'foo', 'foo'>; +//=> never +``` + +@example +``` +type Filtered = Filter<'bar', string>; +//=> never +``` + +@example +``` +type Filtered = Filter<'bar', 'foo'>; +//=> 'bar' +``` + +@see {Except} +*/ +type Filter = IsEqual extends true ? never : (KeyType extends ExcludeType ? never : KeyType); + +/** +Create a type from an object type without certain keys. + +This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically. + +This type was proposed to the TypeScript team, which declined it, saying they prefer that libraries implement stricter versions of the built-in types ([microsoft/TypeScript#30825](https://github.com/microsoft/TypeScript/issues/30825#issuecomment-523668235)). + +@example +``` +import type {Except} from 'type-fest'; + +type Foo = { + a: number; + b: string; + c: boolean; +}; + +type FooWithoutA = Except; +//=> {b: string}; +``` + +@category Object +*/ +export type Except = { + [KeyType in keyof ObjectType as Filter]: ObjectType[KeyType]; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/fixed-length-array.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/fixed-length-array.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9152e906b57c53b7f6858b4a480c070b36448765 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/fixed-length-array.d.ts @@ -0,0 +1,43 @@ +/** +Methods to exclude. +*/ +type ArrayLengthMutationKeys = 'splice' | 'push' | 'pop' | 'shift' | 'unshift'; + +/** +Create a type that represents an array of the given type and length. The array's length and the `Array` prototype methods that manipulate its length are excluded in the resulting type. + +Please participate in [this issue](https://github.com/microsoft/TypeScript/issues/26223) if you want to have a similiar type built into TypeScript. + +Use-cases: +- Declaring fixed-length tuples or arrays with a large number of items. +- Creating a range union (for example, `0 | 1 | 2 | 3 | 4` from the keys of such a type) without having to resort to recursive types. +- Creating an array of coordinates with a static length, for example, length of 3 for a 3D vector. + +Note: This type does not prevent out-of-bounds access. Prefer `ReadonlyTuple` unless you need mutability. + +@example +``` +import type {FixedLengthArray} from 'type-fest'; + +type FencingTeam = FixedLengthArray; + +const guestFencingTeam: FencingTeam = ['Josh', 'Michael', 'Robert']; + +const homeFencingTeam: FencingTeam = ['George', 'John']; +//=> error TS2322: Type string[] is not assignable to type 'FencingTeam' + +guestFencingTeam.push('Sam'); +//=> error TS2339: Property 'push' does not exist on type 'FencingTeam' +``` + +@category Array +@see ReadonlyTuple +*/ +export type FixedLengthArray = Pick< + ArrayPrototype, + Exclude +> & { + [index: number]: Element; + [Symbol.iterator]: () => IterableIterator; + readonly length: Length; +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/get.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/get.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a95394c0073f2e304fbb2d674e0f2b28466db3ab --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/get.d.ts @@ -0,0 +1,184 @@ +import type {StringDigit} from '../source/internal'; +import type {Split} from './split'; +import type {StringKeyOf} from './string-key-of'; + +type GetOptions = { + strict?: boolean; +}; + +/** +Like the `Get` type but receives an array of strings as a path parameter. +*/ +type GetWithPath = + Keys extends [] + ? BaseType + : Keys extends readonly [infer Head, ...infer Tail] + ? GetWithPath< + PropertyOf, Options>, + Extract, + Options + > + : never; + +/** +Adds `undefined` to `Type` if `strict` is enabled. +*/ +type Strictify = + Options['strict'] extends true ? Type | undefined : Type; + +/** +If `Options['strict']` is `true`, includes `undefined` in the returned type when accessing properties on `Record`. + +Known limitations: +- Does not include `undefined` in the type on object types with an index signature (for example, `{a: string; [key: string]: string}`). +*/ +type StrictPropertyOf = + Record extends BaseType + ? string extends keyof BaseType + ? Strictify // Record + : BaseType[Key] // Record<'a' | 'b', any> (Records with a string union as keys have required properties) + : BaseType[Key]; + +/** +Splits a dot-prop style path into a tuple comprised of the properties in the path. Handles square-bracket notation. + +@example +``` +ToPath<'foo.bar.baz'> +//=> ['foo', 'bar', 'baz'] + +ToPath<'foo[0].bar.baz'> +//=> ['foo', '0', 'bar', 'baz'] +``` +*/ +type ToPath = Split, '.'>; + +/** +Replaces square-bracketed dot notation with dots, for example, `foo[0].bar` -> `foo.0.bar`. +*/ +type FixPathSquareBrackets = + Path extends `[${infer Head}]${infer Tail}` + ? Tail extends `[${string}` + ? `${Head}.${FixPathSquareBrackets}` + : `${Head}${FixPathSquareBrackets}` + : Path extends `${infer Head}[${infer Middle}]${infer Tail}` + ? `${Head}.${FixPathSquareBrackets<`[${Middle}]${Tail}`>}` + : Path; + +/** +Returns true if `LongString` is made up out of `Substring` repeated 0 or more times. + +@example +``` +ConsistsOnlyOf<'aaa', 'a'> //=> true +ConsistsOnlyOf<'ababab', 'ab'> //=> true +ConsistsOnlyOf<'aBa', 'a'> //=> false +ConsistsOnlyOf<'', 'a'> //=> true +``` +*/ +type ConsistsOnlyOf = + LongString extends '' + ? true + : LongString extends `${Substring}${infer Tail}` + ? ConsistsOnlyOf + : false; + +/** +Convert a type which may have number keys to one with string keys, making it possible to index using strings retrieved from template types. + +@example +``` +type WithNumbers = {foo: string; 0: boolean}; +type WithStrings = WithStringKeys; + +type WithNumbersKeys = keyof WithNumbers; +//=> 'foo' | 0 +type WithStringsKeys = keyof WithStrings; +//=> 'foo' | '0' +``` +*/ +type WithStringKeys = { + [Key in StringKeyOf]: UncheckedIndex +}; + +/** +Perform a `T[U]` operation if `T` supports indexing. +*/ +type UncheckedIndex = [T] extends [Record] ? T[U] : never; + +/** +Get a property of an object or array. Works when indexing arrays using number-literal-strings, for example, `PropertyOf = number`, and when indexing objects with number keys. + +Note: +- Returns `unknown` if `Key` is not a property of `BaseType`, since TypeScript uses structural typing, and it cannot be guaranteed that extra properties unknown to the type system will exist at runtime. +- Returns `undefined` from nullish values, to match the behaviour of most deep-key libraries like `lodash`, `dot-prop`, etc. +*/ +type PropertyOf = + BaseType extends null | undefined + ? undefined + : Key extends keyof BaseType + ? StrictPropertyOf + : BaseType extends [] | [unknown, ...unknown[]] + ? unknown // It's a tuple, but `Key` did not extend `keyof BaseType`. So the index is out of bounds. + : BaseType extends { + [n: number]: infer Item; + length: number; // Note: This is needed to avoid being too lax with records types using number keys like `{0: string; 1: boolean}`. + } + ? ( + ConsistsOnlyOf extends true + ? Strictify + : unknown + ) + : Key extends keyof WithStringKeys + ? StrictPropertyOf, Key, Options> + : unknown; + +// This works by first splitting the path based on `.` and `[...]` characters into a tuple of string keys. Then it recursively uses the head key to get the next property of the current object, until there are no keys left. Number keys extract the item type from arrays, or are converted to strings to extract types from tuples and dictionaries with number keys. +/** +Get a deeply-nested property from an object using a key path, like Lodash's `.get()` function. + +Use-case: Retrieve a property from deep inside an API response or some other complex object. + +@example +``` +import type {Get} from 'type-fest'; +import * as lodash from 'lodash'; + +const get = (object: BaseType, path: Path): Get => + lodash.get(object, path); + +interface ApiResponse { + hits: { + hits: Array<{ + _id: string + _source: { + name: Array<{ + given: string[] + family: string + }> + birthDate: string + } + }> + } +} + +const getName = (apiResponse: ApiResponse) => + get(apiResponse, 'hits.hits[0]._source.name'); + //=> Array<{given: string[]; family: string}> + +// Path also supports a readonly array of strings +const getNameWithPathArray = (apiResponse: ApiResponse) => + get(apiResponse, ['hits','hits', '0', '_source', 'name'] as const); + //=> Array<{given: string[]; family: string}> + +// Strict mode: +Get //=> string | undefined +Get, 'foo', {strict: true}> // => string | undefined +``` + +@category Object +@category Array +@category Template literal +*/ +export type Get = + GetWithPath : Path, Options>; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/has-optional-keys.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/has-optional-keys.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..597e8aaa18ba960f60c16b554ec96b04349bc22e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/has-optional-keys.d.ts @@ -0,0 +1,21 @@ +import {OptionalKeysOf} from './optional-keys-of'; + +/** +Creates a type that represents `true` or `false` depending on whether the given type has any optional fields. + +This is useful when you want to create an API whose behavior depends on the presence or absence of optional fields. + +@example +``` +import type {HasOptionalKeys, OptionalKeysOf} from 'type-fest'; + +type UpdateService = { + removeField: HasOptionalKeys extends true + ? (field: OptionalKeysOf) => Promise + : never +} +``` + +@category Utilities +*/ +export type HasOptionalKeys = OptionalKeysOf extends never ? false : true; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/has-required-keys.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/has-required-keys.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ec9daf368d5a1cb034c32cb4310e8e4639700b14 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/read-pkg-up/node_modules/type-fest/source/has-required-keys.d.ts @@ -0,0 +1,59 @@ +import {RequiredKeysOf} from './required-keys-of'; + +/** +Creates a type that represents `true` or `false` depending on whether the given type has any required fields. + +This is useful when you want to create an API whose behavior depends on the presence or absence of required fields. + +@example +``` +import type {HasRequiredKeys} from 'type-fest'; + +type GeneratorOptions