The code imports dependencies, including a selectAst function, and uses it to define a getRequires function that extracts require statements from JavaScript code. The getRequires function is then exported as a module, making it available for use in other parts of the application.
This code imports a getRequires function from a module, uses it to extract required modules from a JavaScript code string, and exports the result as a module. The code is conditionally executed when a variable $ is defined in the global scope, printing the expected output: ../Core, glob, and path.
The relativeImports function analyzes a code snippet to identify required modules, categorizing them into local, built-in, packages, and missing modules. It returns an object with arrays of these categories, using various checks and resolutions to determine the type and location of each module.
This code provides a module that exports a function coreDependencies which retrieves and logs package dependencies from notebooks in a project directory, excluding cache.ipynb.
The code imports dependencies, defines a testCoreDependencies function that calls and returns a coreDependencies function, and exports it as a module. The function is conditionally executed if the global variable $ is defined, likely for debugging or testing purposes.
The getExports function uses the selectAst function to extract exports and function names from the Abstract Syntax Tree (AST) of a given code, and returns a filtered array of unique function names. The function is then exported as a module, allowing it to be used in other parts of the application.
The code imports modules, defines a code snippet, and a function to test the behavior of getExports, which is expected to return a specific output when executed with the code snippet.
The code imports modules and defines a function testGetExports() to test the behavior of getExports() on a given code snippet. The expected output of testGetExports() is a specific string containing lines of code that modify the exports object.
The code defines a getParameters function that extracts function parameters from a given code string by using XPath queries to parse an Abstract Syntax Tree (AST). The function is exported as a module and can be used in other parts of the application to retrieve function parameters.
The code imports a module named importer and a function get parameter names from it, assigns it to the getParameters variable, and defines a function to test it. However, the purpose of the code is unclear without more context, but it appears to be a test case for the getParameters function.
The getImports function extracts import information from a given code string by parsing an Abstract Syntax Tree (AST) and selecting specific nodes using XPath-like query strings. It is exported as a module and returns an array of import information, removing duplicates in the process.
This code imports modules, defines sample JavaScript code, and tests a function getImports on various inputs, including a file and a string, and logs the results in a conditional block.
The wireKernelInterface object is a JavaScript implementation of the Meta Kernel protocol, defining properties and methods for handling various requests and replies, such as execution, inspection, and communication. The object is exported as a module using module.exports, allowing other JavaScript files to import and use it.
The code imports dependencies, defines a function to remove Unicode characters, and implements a treeToStr function to recursively convert a statement tree to a string, handling various data types and attributes. The treeToStr function traverses the tree, escaping special characters and including type attributes in the string representation.
The htmlToTree function takes an HTML string or tree as input and returns the corresponding tree structure by parsing and recursively processing its child nodes using the accumulateChildNodes function.
Alternatively, you can also summarize it in two sentences:
The htmlToTree function uses the JSDOM library to parse the input HTML and process its child nodes using the accumulateChildNodes function. It can handle HTML strings, arrays, and text nodes, and it recursively processes attribute objects to convert their attributes to properties.
This code imports necessary modules, defines functions for parsing and converting JavaScript code into HTML, and exports the testASTArray function for use in other modules. It also includes functionality for encoding HTML entities and assumes the presence of specific functions and an object ($) in the execution environment.
The code imports modules and functions from a parent directory, defines a function testHtmlTree to translate HTML into a tree-like structure using the htmlToTree function, and provides an example usage of the function by parsing HTML from a Google search page and logging the result to the console. The code also includes a conditional statement to check if the $ variable is defined, but no code is executed within the block.
The Node.js module exports two functions, selectAst and makeExpr, which are used for parsing and manipulating JavaScript code, and require dependencies such as esprima and escodegen. The functions work together to convert code to HTML, generate string representations of ASTs, and parse code to extract its structure and content.
The code tests a given code string by selecting specific HTML nodes and logging their properties to the console. The code uses several functions from the importer, which is imported from the ../Core module, to perform the necessary operations.
The code uses the acorn JavaScript parser to parse code and collect comments and tokens, and the ../Core module to export necessary functions. It exports the selectAcorn(descriptor, code) function, which parses the code, selects an AST, and converts it to a tree structure using the htmlToTree(call) function.
The code requires two dependencies (assert and importer) and defines two functions: makeCombinations, which generates all possible combinations of a given array of values, and makeXpaths, which constructs a specific XPath expression based on a given node's properties. The makeXpaths function uses the selectDom function to select the first occurrence of the classifiers from the node and constructs the XPath expression based on properties such as tag name, ID, class names, and index.
The code requires several modules and defines a function testMakeXpaths that tests the functionality of the makeXpaths function by generating XPath expressions for a function declaration node and asserting that its parent has an expected attribute. The function also logs the result, including an HTML representation of the tree structure if the $ variable is defined.
The minXpath function takes an array of XPath expressions and a context object, filters them to match exactly one DOM element, sorts them by length, and returns the shortest one. It is exported as a module named minXpath for use in other parts of the application.
The convertXPathToCss function takes an XPath expression and converts it to a CSS selector, performing replacements such as removing // separators, replacing contains with attribute selectors, and rewriting descendant combinators. The function returns the converted CSS selector.
The exprToXpath function takes in a code parameter and uses various dependencies to convert it into an XPath expression, including selecting function declarations, extracting parameter names, and creating minimizing expressions. This function is then exported as a module, making it available for use in other parts of the application.
The code checks if the global object $ is defined and, if so, calls the exprToXpath function with a callback that imports the importer object, which is then used to log an Xpath variable to the console. The replaceCore function is commented out, but its implementation is not provided in the code snippet.
The code is a Node.js module that exports a function testExpressions, which generates an XPath expression from the findImport function and searches for cells in the cellCache array that match the expression. If the $ variable is defined, the function is called and its result is sent to the $ object using the sendResult method.
This code snippet, likely written in JavaScript, declares a variable named STATEMENTS and selects elements in an XML or HTML document using XPath expressions that target elements with specific attribute values. The XPath expressions are combined using a logical OR operator to select elements with either "Declaration" or "Statement" in their type attribute.
The code var CALLS = defines a variable named CALLS and assigns it a string value. The string value is a JavaScript comment //CallExpression, enclosed in template literals to prevent it from being interpreted as a comment.
The code declares a variable named BRANCHES with a string value of //IfStatement|SwitchStatement, which appears to be a delimiter or pattern for identifying specific programming constructs. This variable stores a string that may be used to separate or identify different types of programming constructs, such as conditional statements and compound statements.