{"_id":"@codyjasonbennett/shaderkit-bundlephobia-test","name":"@codyjasonbennett/shaderkit-bundlephobia-test","dist-tags":{"latest":"0.4.1"},"versions":{"0.4.1":{"name":"@codyjasonbennett/shaderkit-bundlephobia-test","version":"0.4.1","description":"Tools and IntelliSense for GLSL and WGSL.","keywords":["shaders","glsl","wgsl","webgl","webgpu","compiler","parser","minifier","intellisense"],"author":{"name":"Cody Bennett","url":"https://github.com/CodyJasonBennett"},"homepage":"https://github.com/CodyJasonBennett/shaderkit","repository":{"type":"git","url":"https://github.com/CodyJasonBennett/shaderkit"},"license":"MIT","type":"module","main":"./dist/index.js","exports":"./dist/index.js","sideEffects":false,"devDependencies":{"@types/node":"^22.10.2","typescript":"^5.7.2","vite":"^6.0.6","vitest":"^2.1.8"},"scripts":{"dev":"vite","build":"vite build","lint":"tsc","test":"vitest run"},"licenseText":"MIT License\n\nCopyright (c) 2023-2025 Cody Bennett\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n","_id":"@codyjasonbennett/shaderkit-bundlephobia-test@0.4.1","dist":{"shasum":"2cee08bcbed50b205b4d5c18aec4569747388bfe","integrity":"sha512-VMhcB0oIGzlUMchZbw5VcRBowUkZT9N4NkQujuM5gegqWnO6iLnDIEWCegOOqzvXmJU0TjbU2yFQ9Fv6W5PpGw==","tarball":"https://registry.npmjs.org/@codyjasonbennett/shaderkit-bundlephobia-test/-/shaderkit-bundlephobia-test-0.4.1.tgz","fileCount":17,"unpackedSize":136877,"signatures":[{"keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U","sig":"MEYCIQC+GdFt1wuArma406Z/BkitcgVVvwWjhPxsMSANpEt9PQIhAIBwJEp8fR/o8J7qKGkofIeqhMKDZXG1CN69JnuKFHNU"}]},"_npmUser":{"name":"codyjasonbennett","email":"hi@codyb.co"},"directories":{},"maintainers":[{"name":"codyjasonbennett","email":"hi@codyb.co"}],"_npmOperationalInternal":{"host":"s3://npm-registry-packages-npm-production","tmp":"tmp/shaderkit-bundlephobia-test_0.4.1_1739490414979_0.9257910687189268"},"_hasShrinkwrap":false}},"time":{"created":"2025-02-13T23:46:54.841Z","0.4.1":"2025-02-13T23:46:55.200Z","modified":"2025-02-13T23:46:55.447Z"},"maintainers":[{"name":"codyjasonbennett","email":"hi@codyb.co"}],"description":"Tools and IntelliSense for GLSL and WGSL.","homepage":"https://github.com/CodyJasonBennett/shaderkit","keywords":["shaders","glsl","wgsl","webgl","webgpu","compiler","parser","minifier","intellisense"],"repository":{"type":"git","url":"https://github.com/CodyJasonBennett/shaderkit"},"author":{"name":"Cody Bennett","url":"https://github.com/CodyJasonBennett"},"license":"MIT","readme":"[![Size](https://img.shields.io/bundlephobia/minzip/shaderkit?label=gzip&style=flat&colorA=000000&colorB=000000)](https://bundlephobia.com/package/shaderkit)\n[![Version](https://img.shields.io/npm/v/shaderkit?style=flat&colorA=000000&colorB=000000)](https://npmjs.com/package/shaderkit)\n[![Downloads](https://img.shields.io/npm/dt/shaderkit.svg?style=flat&colorA=000000&colorB=000000)](https://npmjs.com/package/shaderkit)\n\n# shaderkit\n\nTools and IntelliSense for GLSL and WGSL.\n\n## Table of Contents\n\n- [Installation](#installation)\n- [Tokenize](#tokenize)\n- [Minify](#minify)\n- [Parse](#parse)\n- [Generate](#generate)\n- [Visit](#visit)\n- [AST](#ast)\n  - [Node Objects](#node-objects)\n  - [Identifier](#identifier)\n  - [Literal](#literal)\n  - [ArraySpecifier](#arrayspecifier)\n  - [Program](#program)\n  - Statements\n    - [ExpressionStatement](#expressionstatement)\n    - [BlockStatement](#blockstatement)\n    - [DiscardStatement](#discardstatement)\n    - [PreprocessorStatement](#preprocessorstatement)\n    - [PrecisionStatement](#precisionstatement)\n    - Control Flow\n      - [ReturnStatement](#returnstatement)\n      - [BreakStatement](#breakstatement)\n      - [ContinueStatement](#continuestatement)\n    - Choice\n      - [IfStatement](#ifstatement)\n      - [SwitchStatement](#switchstatement)\n        - [SwitchCase](#switchcase)\n    - Loops\n      - [WhileStatement](#whilestatement)\n      - [DoWhileStatement](#dowhilestatement)\n      - [ForStatement](#forstatement)\n  - Declarations\n    - [FunctionDeclaration](#functiondeclaration)\n      - [FunctionParameter](#functionparameter)\n    - [VariableDeclaration](#variabledeclaration)\n      - [VariableDeclarator](#variabledeclarator)\n    - [UniformDeclarationBlock](#uniformdeclarationblock)\n    - [StructDeclaration](#structdeclaration)\n  - Expressions\n    - [ArrayExpression](#arrayexpression)\n    - Unary Operations\n      - [UnaryExpression](#unaryexpression)\n        - [UnaryOperator](#unaryoperator)\n      - [UpdateExpression](#updateexpression)\n        - [UpdateOperator](#updateoperator)\n    - Binary Operations\n      - [BinaryExpression](#binaryexpression)\n        - [BinaryOperator](#binaryoperator)\n      - [AssignmentExpression](#assignmentexpression)\n        - [AssignmentOperator](#assignmentoperator)\n      - [LogicalExpression](#logicalexpression)\n        - [LogicalOperator](#logicaloperator)\n      - [MemberExpression](#memberexpression)\n    - [ConditionalExpression](#conditionalexpression)\n    - [CallExpression](#callexpression)\n\n## Installation\n\nTo install, use your preferred package manager:\n\n```bash\nnpm install shaderkit\nyarn add shaderkit\npnpm add shaderkit\n```\n\nOr, use a CDN:\n\n```html\n<script type=\"module\">\n  import * as shaderkit from 'https://unpkg.com/shaderkit'\n</script>\n```\n\n## Tokenize\n\nTokenizes a string of GLSL or WGSL code, returning an array of `Token` objects, where each `Token` object represents a single syntax feature in the input code.\n\n```ts\ninterface Token {\n  type: 'whitespace' | 'comment' | 'symbol' | 'bool' | 'float' | 'int' | 'identifier' | 'keyword'\n  value: string\n}\n```\n\n<details>\n  <summary>GLSL Example</summary>\n  \n  <br />\n\n```ts\nimport { tokenize } from 'shaderkit'\n\nconst code = 'void main() { gl_Position = vec4(0, 0, 0, 1); }'\nconst tokens = tokenize(code)\n\nconsole.log(tokens)\n```\n\nThe output of the above code will be:\n\n```json\n[\n  { \"type\": \"keyword\", \"value\": \"void\" },\n  { \"type\": \"whitespace\", \"value\": \" \" },\n  { \"type\": \"identifier\", \"value\": \"main\" },\n  { \"type\": \"symbol\", \"value\": \"(\" },\n  { \"type\": \"symbol\", \"value\": \")\" },\n  { \"type\": \"whitespace\", \"value\": \" \" },\n  { \"type\": \"symbol\", \"value\": \"{\" },\n  { \"type\": \"whitespace\", \"value\": \" \" },\n  { \"type\": \"keyword\", \"value\": \"gl_Position\" },\n  { \"type\": \"whitespace\", \"value\": \" \" },\n  { \"type\": \"symbol\", \"value\": \"=\" },\n  { \"type\": \"whitespace\", \"value\": \" \" },\n  { \"type\": \"keyword\", \"value\": \"vec4\" },\n  { \"type\": \"symbol\", \"value\": \"(\" },\n  { \"type\": \"int\", \"value\": \"0\" },\n  { \"type\": \"symbol\", \"value\": \",\" },\n  { \"type\": \"whitespace\", \"value\": \" \" },\n  { \"type\": \"int\", \"value\": \"0\" },\n  { \"type\": \"symbol\", \"value\": \",\" },\n  { \"type\": \"whitespace\", \"value\": \" \" },\n  { \"type\": \"int\", \"value\": \"0\" },\n  { \"type\": \"symbol\", \"value\": \",\" },\n  { \"type\": \"whitespace\", \"value\": \" \" },\n  { \"type\": \"int\", \"value\": \"1\" },\n  { \"type\": \"symbol\", \"value\": \")\" },\n  { \"type\": \"symbol\", \"value\": \";\" },\n  { \"type\": \"whitespace\", \"value\": \" \" },\n  { \"type\": \"symbol\", \"value\": \"}\" }\n]\n```\n\n</details>\n\n<details>\n  <summary>WGSL Example</summary>\n  \n  <br />\n\n```ts\nimport { tokenize } from 'shaderkit'\n\nconst code = '@vertex fn main() -> @builtin(position) vec4<f32> { return vec4(0, 0, 0, 1); }'\nconst tokens = tokenize(code)\n\nconsole.log(tokens)\n```\n\nThe output of the above code will be:\n\n```json\n[\n  { \"type\": \"symbol\", \"value\": \"@\" },\n  { \"type\": \"keyword\", \"value\": \"vertex\" },\n  { \"type\": \"whitespace\", \"value\": \" \" },\n  { \"type\": \"keyword\", \"value\": \"fn\" },\n  { \"type\": \"whitespace\", \"value\": \" \" },\n  { \"type\": \"identifier\", \"value\": \"main\" },\n  { \"type\": \"symbol\", \"value\": \"(\" },\n  { \"type\": \"symbol\", \"value\": \")\" },\n  { \"type\": \"whitespace\", \"value\": \" \" },\n  { \"type\": \"symbol\", \"value\": \"->\" },\n  { \"type\": \"whitespace\", \"value\": \" \" },\n  { \"type\": \"symbol\", \"value\": \"@\" },\n  { \"type\": \"keyword\", \"value\": \"builtin\" },\n  { \"type\": \"symbol\", \"value\": \"(\" },\n  { \"type\": \"keyword\", \"value\": \"position\" },\n  { \"type\": \"symbol\", \"value\": \")\" },\n  { \"type\": \"whitespace\", \"value\": \" \" },\n  { \"type\": \"keyword\", \"value\": \"vec4\" },\n  { \"type\": \"symbol\", \"value\": \"<\" },\n  { \"type\": \"keyword\", \"value\": \"f32\" },\n  { \"type\": \"symbol\", \"value\": \">\" },\n  { \"type\": \"whitespace\", \"value\": \" \" },\n  { \"type\": \"symbol\", \"value\": \"{\" },\n  { \"type\": \"whitespace\", \"value\": \" \" },\n  { \"type\": \"keyword\", \"value\": \"return\" },\n  { \"type\": \"whitespace\", \"value\": \" \" },\n  { \"type\": \"keyword\", \"value\": \"vec4\" },\n  { \"type\": \"symbol\", \"value\": \"(\" },\n  { \"type\": \"int\", \"value\": \"0\" },\n  { \"type\": \"symbol\", \"value\": \",\" },\n  { \"type\": \"whitespace\", \"value\": \" \" },\n  { \"type\": \"int\", \"value\": \"0\" },\n  { \"type\": \"symbol\", \"value\": \",\" },\n  { \"type\": \"whitespace\", \"value\": \" \" },\n  { \"type\": \"int\", \"value\": \"0\" },\n  { \"type\": \"symbol\", \"value\": \",\" },\n  { \"type\": \"whitespace\", \"value\": \" \" },\n  { \"type\": \"int\", \"value\": \"1\" },\n  { \"type\": \"symbol\", \"value\": \")\" },\n  { \"type\": \"symbol\", \"value\": \";\" },\n  { \"type\": \"whitespace\", \"value\": \" \" },\n  { \"type\": \"symbol\", \"value\": \"}\" }\n]\n```\n\n</details>\n\nThe following are the supported token types and their descriptions:\n\n| Type       | Description                                                               |\n| ---------- | ------------------------------------------------------------------------- |\n| whitespace | A sequence of one or more whitespace characters.                          |\n| comment    | A single-line or multi-line comment.                                      |\n| symbol     | A symbol, such as an operator or punctuation mark.                        |\n| bool       | A boolean value, either true or false.                                    |\n| float      | A floating-point number, represented by a sequence of digits and symbols. |\n| int        | An integer number, represented by a sequence of digits.                   |\n| identifier | A user-defined identifier, such as a variable name or function name.      |\n| keyword    | A keyword reserved by the language, such as if, else, for, etc.           |\n\n## Minify\n\nMinifies a string of GLSL or WGSL code, returning a minified version of the input code.\n\n```ts\nconst minified: string = minify(code: string, {\n  /** Whether to rename variables. Will call a MangleMatcher if specified. Default is `false`. */\n  mangle: boolean | ((token: Token, index: number, tokens: Token[]) => boolean)\n  /** A map to read and write renamed variables to when mangling. */\n  mangleMap: Map<string, string>\n  /** Whether to rename external variables such as uniforms or varyings. Default is `false`. */\n  mangleExternals: boolean\n})\n```\n\nTo shared mangled interfaces when using `mangleExternal`, declare and re-use a `mangleMap` between shaders:\n\n```ts\nconst options = { mangle: true, mangleExternals: true, mangleMap: new Map() }\n\n// #version 300 es\\nin vec2 a;out vec2 b;void main(){b=a;}\nminify(`#version 300 es\\nin vec2 sstt;out vec2 c;void main(){c=sstt;}`, options)\n\n// #version 300 es\\nin vec2 b;out vec4 a[gl_MaxDrawBuffers];void main(){a[0]=b.sstt;}\nminify(`#version 300 es\\nin vec2 c;out vec4 data[gl_MaxDrawBuffers];void main(){data[0]=c.sstt;}`, options)\n```\n\n## Parse\n\nParses a string of GLSL (WGSL is WIP) code into an [AST](#ast).\n\n```ts\nconst ast: Program = parse(code: string)\n```\n\n## Generate\n\nGenerates a string of GLSL (WGSL is WIP) code from an [AST](#ast).\n\n```ts\nconst code: string = generate(program: Program, {\n  target: 'GLSL' // | 'WGSL'\n})\n```\n\n## Visit\n\nRecurses through an [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree), calling a visitor object on matching nodes.\n\n```ts\nvisit(\n  program: Program,\n  visitors: {\n    Program: {\n      enter(node, ancestors) {\n        // Called before any descendant nodes are processed\n      },\n      exit(node, ancestors) {\n        // Called after all nodes are processed\n      }\n    },\n    Identifier(node, ancestors) {\n      // Called before any descendant nodes are processed (alias to enter)\n    }\n  } satisfies Visitors\n)\n```\n\n## AST\n\nAn [Abstract Syntax Tree](https://en.wikipedia.org/wiki/Abstract_syntax_tree) loosely based on [ESTree](https://github.com/estree/estree) for GLSL and WGSL grammars.\n\n### Node Objects\n\nAST nodes extend `Node` objects which implement the following abstract interface:\n\n```ts\ninterface Node {\n  type: string\n}\n```\n\nThe `type` field is a string representing the AST variant type which can determine the interface a node implements.\n\n### Identifier\n\nA variable identifier.\n\n```ts\ninterface Identifier extends Node {\n  type: 'Identifier'\n  name: string\n}\n```\n\n### Literal\n\nA shader literal representing a `bool`, `float`, `int`, or `uint` type.\n\n```ts\ninterface Literal extends Node {\n  type: 'Literal'\n  value: string\n}\n```\n\n### ArraySpecifier\n\nAn array and its dimensions.\n\n```ts\ninterface ArraySpecifier extends Node {\n  type: 'ArraySpecifier'\n  typeSpecifier: Identifier\n  dimensions: (Literal | Identifier | null)[]\n}\n```\n\n### Program\n\nRepresents the root of an AST.\n\n```ts\ninterface Program extends Node {\n  type: 'Program'\n  body: Statement[]\n}\n```\n\n### ExpressionStatement\n\nAn expression as a standalone statement.\n\n```ts\ninterface ExpressionStatement extends Node {\n  type: 'ExpressionStatement'\n  expression: Expression\n}\n```\n\n### BlockStatement\n\nA block statement.\n\n```ts\ninterface BlockStatement extends Node {\n  type: 'BlockStatement'\n  body: Statement[]\n}\n```\n\n### DiscardStatement\n\nA discard statement in fragment shaders.\n\n```ts\ninterface DiscardStatement extends Node {\n  type: 'DiscardStatement'\n}\n```\n\n### PreprocessorStatement\n\nA GLSL preprocessor statement with an optional value.\n\n```ts\ninterface PreprocessorStatement extends Node {\n  type: 'PreprocessorStatement'\n  name: string\n  value: Expression[] | null\n}\n```\n\n### PrecisionStatement\n\nA GLSL precision statement.\n\n```ts\ninterface PrecisionStatement extends Node {\n  type: 'PrecisionStatement'\n  precision: PrecisionQualifier\n  typeSpecifier: Identifier\n}\n```\n\n### ReturnStatement\n\nA return statement with an optional argument.\n\n```ts\ninterface ReturnStatement extends Node {\n  type: 'ReturnStatement'\n  argument: Expression | null\n}\n```\n\n### BreakStatement\n\nA break statement.\n\n```ts\ninterface BreakStatement extends Node {\n  type: 'BreakStatement'\n}\n```\n\n### ContinueStatement\n\nA continue statement.\n\n```ts\ninterface ContinueStatement extends Node {\n  type: 'ContinueStatement'\n}\n```\n\n### IfStatement\n\nAn if-else statement.\n\n```ts\ninterface IfStatement extends Node {\n  type: 'IfStatement'\n  test: Expression\n  consequent: Statement\n  alternate: Statement | null\n}\n```\n\n### SwitchStatement\n\nA switch statement.\n\n```ts\ninterface SwitchStatement extends Node {\n  type: 'SwitchStatement'\n  discriminant: Expression\n  cases: SwitchCase[]\n}\n```\n\n#### SwitchCase\n\nA switch-case statement. `test` is null for a `default` case.\n\n```ts\ninterface SwitchCase extends Node {\n  type: 'SwitchCase'\n  test: Expression | null\n  consequent: Statement[]\n}\n```\n\n### WhileStatement\n\nA while statement.\n\n```ts\ninterface WhileStatement extends Node {\n  type: 'WhileStatement'\n  test: Expression\n  body: Statement\n}\n```\n\n### DoWhileStatement\n\nA do-while statement.\n\n```ts\ninterface DoWhileStatement extends Node {\n  type: 'DoWhileStatement'\n  body: Statement\n  test: Expression\n}\n```\n\n### ForStatement\n\nA for statement.\n\n```ts\ninterface ForStatement extends Node {\n  type: 'ForStatement'\n  init: VariableDeclaration | Expression | null\n  test: Expression | null\n  update: Expression | null\n  body: Statement\n}\n```\n\n### FunctionDeclaration\n\nA function declaration. `body` is null for overloads.\n\n```ts\ninterface FunctionDeclaration extends Node {\n  type: 'FunctionDeclaration'\n  id: Identifier\n  qualifiers: PrecisionQualifier[]\n  typeSpecifier: Identifier | ArraySpecifier\n  params: FunctionParameter[]\n  body: BlockStatement | null\n}\n```\n\n#### FunctionParameter\n\nA function parameter within a function declaration.\n\n```ts\ninterface FunctionParameter extends Node {\n  type: 'FunctionParameter'\n  id: Identifier\n  qualifiers: (ConstantQualifier | ParameterQualifier | PrecisionQualifier)[]\n  typeSpecifier: Identifier | ArraySpecifier\n}\n```\n\n### VariableDeclaration\n\nA variable declaration.\n\n```ts\ninterface VariableDeclaration extends Node {\n  type: 'VariableDeclaration'\n  declarations: VariableDeclarator[]\n}\n```\n\n#### VariableDeclarator\n\nA variable declarator within a variable declaration.\n\n```ts\ninterface VariableDeclarator extends Node {\n  type: 'VariableDeclarator'\n  id: Identifier\n  qualifiers: (ConstantQualifier | InterpolationQualifier | StorageQualifier | PrecisionQualifier)[]\n  typeSpecifier: Identifier | ArraySpecifier\n  layout: Record<string, string | boolean> | null\n  init: Expression | null\n}\n```\n\n### UniformDeclarationBlock\n\nA uniform declaration block with optional layout and qualifiers.\n\n```ts\ninterface UniformDeclarationBlock extends Node {\n  type: 'UniformDeclarationBlock'\n  id: Identifier | null\n  qualifiers: LayoutQualifier[]\n  typeSpecifier: Identifier | ArraySpecifier\n  layout: Record<string, string | boolean> | null\n  members: VariableDeclaration[]\n}\n```\n\n### StructDeclaration\n\nA struct declaration. Can be used as a type or constructor.\n\n```ts\ninterface StructDeclaration extends Node {\n  type: 'StructDeclaration'\n  id: Identifier\n  members: VariableDeclaration[]\n}\n```\n\n### ArrayExpression\n\nAn array initialization expression.\n\n```ts\ninterface ArrayExpression extends Node {\n  type: 'ArrayExpression'\n  typeSpecifier: ArraySpecifier\n  elements: Expression[]\n}\n```\n\n### UnaryExpression\n\nA unary expression with a left or right handed operator.\n\n```ts\ninterface UnaryExpression extends Node {\n  type: 'UnaryExpression'\n  operator: UnaryOperator\n  prefix: boolean\n  argument: Expression\n}\n```\n\n#### UnaryOperator\n\n```ts\ntype UnaryOperator = '-' | '+' | '!' | '~'\n```\n\n### UpdateExpression\n\nAn update expression with an optionally prefixed operator.\n\n```ts\ninterface UpdateExpression extends Node {\n  type: 'UpdateExpression'\n  operator: UpdateOperator\n  argument: Expression\n  prefix: boolean\n}\n```\n\n#### UpdateOperator\n\n```ts\ntype UpdateOperator = '++' | '--'\n```\n\n### BinaryExpression\n\nA binary expression with a left and right operand.\n\n```ts\ninterface BinaryExpression extends Node {\n  type: 'BinaryExpression'\n  operator: BinaryOperator\n  left: Expression\n  right: Expression\n}\n```\n\n#### BinaryOperator\n\n```ts\ntype BinaryOperator =\n  | '=='\n  | '!='\n  | '<'\n  | '<='\n  | '>'\n  | '>='\n  | '<<'\n  | '>>'\n  | '+'\n  | '-'\n  | '*'\n  | '/'\n  | '%'\n  | '|'\n  | '^'\n  | '&'\n```\n\n### AssignmentExpression\n\nAn assignment expression.\n\n```ts\ninterface AssignmentExpression extends Node {\n  type: 'AssignmentExpression'\n  operator: AssignmentOperator\n  left: Expression\n  right: Expression\n}\n```\n\n#### AssignmentOperator\n\n```ts\ntype AssignmentOperator = '=' | '+=' | '-=' | '*=' | '/=' | '%=' | '<<=' | '>>=' | '>>>=' | '|=' | '^=' | '&='\n```\n\n### LogicalExpression\n\nA logical operation between two expressions.\n\n```ts\ninterface LogicalExpression extends Node {\n  type: 'LogicalExpression'\n  operator: LogicalOperator\n  left: Expression\n  right: Expression\n}\n```\n\n#### LogicalOperator\n\n```ts\ntype LogicalOperator = '||' | '&&' | '^^'\n```\n\n### MemberExpression\n\nA member expression.\n\n```ts\ninterface MemberExpression extends Node {\n  type: 'MemberExpression'\n  object: Expression\n  property: Expression\n  computed: boolean\n}\n```\n\n### ConditionalExpression\n\nA conditional expression or ternary.\n\n```ts\ninterface ConditionalExpression extends Node {\n  type: 'ConditionalExpression'\n  test: Expression\n  alternate: Expression\n  consequent: Expression\n}\n```\n\n### CallExpression\n\nA function call expression or struct initialization.\n\n```ts\ninterface CallExpression extends Node {\n  type: 'CallExpression'\n  callee: Expression\n  arguments: Expression[]\n}\n```\n","readmeFilename":"README.md"}