🚀 Big News: Socket Acquires Coana to Bring Reachability Analysis to Every Appsec Team.Learn more →
Socket
DemoInstallSign in
Socket
DemoInstallSign in

@microsoft/powerquery-parser

Package Overview
Dependencies
Maintainers
2
Versions
134
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@microsoft/powerquery-parser - npm Package Compare versions

Comparing version

0.4.16
to
0.4.17

106

lib/powerquery-parser/language/ast/ast.d.ts

@@ -70,3 +70,3 @@ import { Constant } from "..";

export declare type TAuxiliaryNodes = TConstant | FieldSpecification | FieldSpecificationList | FieldTypeSpecification | GeneralizedIdentifier | Identifier | SectionMember | TAnyLiteral | TArrayWrapper | TBinOpExpression | TCsv | TKeyValuePair | TListItem | TNullablePrimitiveType | TPairedConstant | TParameter | TParameterList | TType | TWrapped;
export declare type TArrayWrapper = IArrayWrapper<AsNullablePrimitiveType> | IArrayWrapper<IConstant<Constant.UnaryOperatorKind>> | IArrayWrapper<IsNullablePrimitiveType> | IArrayWrapper<SectionMember> | IArrayWrapper<TRecursivePrimaryExpression> | TCsvArray;
export declare type TArrayWrapper = IArrayWrapper<AsNullablePrimitiveType> | IArrayWrapper<IConstant<Constant.UnaryOperator>> | IArrayWrapper<IsNullablePrimitiveType> | IArrayWrapper<SectionMember> | IArrayWrapper<TRecursivePrimaryExpression> | TCsvArray;
export declare type TCsvArray = ICsvArray<TCsvType>;

@@ -90,5 +90,5 @@ export declare type TCsv = ICsv<TCsvType>;

readonly maybeLiteralAttributes: RecordLiteral | undefined;
readonly sectionConstant: IConstant<Constant.KeywordConstantKind.Section>;
readonly sectionConstant: IConstant<Constant.KeywordConstant.Section>;
readonly maybeName: Identifier | undefined;
readonly semicolonConstant: IConstant<Constant.MiscConstantKind.Semicolon>;
readonly semicolonConstant: IConstant<Constant.MiscConstant.Semicolon>;
readonly sectionMembers: IArrayWrapper<SectionMember>;

@@ -100,5 +100,5 @@ }

readonly maybeLiteralAttributes: RecordLiteral | undefined;
readonly maybeSharedConstant: IConstant<Constant.KeywordConstantKind.Shared> | undefined;
readonly maybeSharedConstant: IConstant<Constant.KeywordConstant.Shared> | undefined;
readonly namePairedExpression: IdentifierPairedExpression;
readonly semicolonConstant: IConstant<Constant.MiscConstantKind.Semicolon>;
readonly semicolonConstant: IConstant<Constant.MiscConstant.Semicolon>;
}

@@ -109,5 +109,5 @@ export declare type TExpression = TNullCoalescingExpression | EachExpression | FunctionExpression | LetExpression | IfExpression | ErrorRaisingExpression | ErrorHandlingExpression;

export declare type TNullablePrimitiveType = NullablePrimitiveType | PrimitiveType;
export interface NullablePrimitiveType extends IPairedConstant<NodeKind.NullablePrimitiveType, Constant.LanguageConstantKind.Nullable, PrimitiveType> {
export interface NullablePrimitiveType extends IPairedConstant<NodeKind.NullablePrimitiveType, Constant.LanguageConstant.Nullable, PrimitiveType> {
}
export interface IsNullablePrimitiveType extends IPairedConstant<NodeKind.IsNullablePrimitiveType, Constant.KeywordConstantKind.Is, TNullablePrimitiveType> {
export interface IsNullablePrimitiveType extends IPairedConstant<NodeKind.IsNullablePrimitiveType, Constant.KeywordConstant.Is, TNullablePrimitiveType> {
}

@@ -117,3 +117,3 @@ export interface PrimitiveType extends INode {

readonly isLeaf: true;
readonly primitiveTypeKind: Constant.PrimitiveTypeConstantKind;
readonly primitiveTypeKind: Constant.PrimitiveTypeConstant;
}

@@ -125,3 +125,3 @@ export declare type TAsExpression = AsExpression | TEqualityExpression;

export declare type TMetadataExpression = MetadataExpression | TUnaryExpression;
export interface MetadataExpression extends IBinOpExpression<NodeKind.MetadataExpression, TUnaryExpression, Constant.KeywordConstantKind.Meta, TUnaryExpression> {
export interface MetadataExpression extends IBinOpExpression<NodeKind.MetadataExpression, TUnaryExpression, Constant.KeywordConstant.Meta, TUnaryExpression> {
}

@@ -132,3 +132,3 @@ export declare type TUnaryExpression = UnaryExpression | TTypeExpression;

readonly isLeaf: false;
readonly operators: IArrayWrapper<IConstant<Constant.UnaryOperatorKind>>;
readonly operators: IArrayWrapper<IConstant<Constant.UnaryOperator>>;
readonly typeExpression: TTypeExpression;

@@ -154,3 +154,3 @@ }

readonly isLeaf: false;
readonly maybeInclusiveConstant: IConstant<Constant.MiscConstantKind.AtSign> | undefined;
readonly maybeInclusiveConstant: IConstant<Constant.MiscConstant.AtSign> | undefined;
readonly identifier: Identifier;

@@ -163,3 +163,3 @@ }

readonly isLeaf: false;
readonly ellipsisConstant: IConstant<Constant.MiscConstantKind.Ellipsis>;
readonly ellipsisConstant: IConstant<Constant.MiscConstant.Ellipsis>;
}

@@ -175,3 +175,3 @@ export interface InvokeExpression extends IParenthesisWrapped<NodeKind.InvokeExpression, ICsvArray<TExpression>> {

readonly left: TExpression;
readonly rangeConstant: IConstant<Constant.MiscConstantKind.DotDot>;
readonly rangeConstant: IConstant<Constant.MiscConstant.DotDot>;
readonly right: TExpression;

@@ -182,10 +182,10 @@ }

export interface ItemAccessExpression extends IBraceWrapped<NodeKind.ItemAccessExpression, TExpression> {
readonly maybeOptionalConstant: IConstant<Constant.MiscConstantKind.QuestionMark> | undefined;
readonly maybeOptionalConstant: IConstant<Constant.MiscConstant.QuestionMark> | undefined;
}
export declare type TFieldAccessExpression = FieldSelector | FieldProjection;
export interface FieldSelector extends IBracketWrapped<NodeKind.FieldSelector, GeneralizedIdentifier> {
readonly maybeOptionalConstant: IConstant<Constant.MiscConstantKind.QuestionMark> | undefined;
readonly maybeOptionalConstant: IConstant<Constant.MiscConstant.QuestionMark> | undefined;
}
export interface FieldProjection extends IBracketWrapped<NodeKind.FieldProjection, ICsvArray<FieldSelector>> {
readonly maybeOptionalConstant: IConstant<Constant.MiscConstantKind.QuestionMark> | undefined;
readonly maybeOptionalConstant: IConstant<Constant.MiscConstant.QuestionMark> | undefined;
}

@@ -197,12 +197,12 @@ export interface FunctionExpression extends INode {

readonly maybeFunctionReturnType: AsNullablePrimitiveType | undefined;
readonly fatArrowConstant: IConstant<Constant.MiscConstantKind.FatArrow>;
readonly fatArrowConstant: IConstant<Constant.MiscConstant.FatArrow>;
readonly expression: TExpression;
}
export interface EachExpression extends IPairedConstant<NodeKind.EachExpression, Constant.KeywordConstantKind.Each, TExpression> {
export interface EachExpression extends IPairedConstant<NodeKind.EachExpression, Constant.KeywordConstant.Each, TExpression> {
}
export interface LetExpression extends INode {
readonly kind: NodeKind.LetExpression;
readonly letConstant: IConstant<Constant.KeywordConstantKind.Let>;
readonly letConstant: IConstant<Constant.KeywordConstant.Let>;
readonly variableList: ICsvArray<IdentifierPairedExpression>;
readonly inConstant: IConstant<Constant.KeywordConstantKind.In>;
readonly inConstant: IConstant<Constant.KeywordConstant.In>;
readonly expression: TExpression;

@@ -213,7 +213,7 @@ }

readonly isLeaf: false;
readonly ifConstant: IConstant<Constant.KeywordConstantKind.If>;
readonly ifConstant: IConstant<Constant.KeywordConstant.If>;
readonly condition: TExpression;
readonly thenConstant: IConstant<Constant.KeywordConstantKind.Then>;
readonly thenConstant: IConstant<Constant.KeywordConstant.Then>;
readonly trueExpression: TExpression;
readonly elseConstant: IConstant<Constant.KeywordConstantKind.Else>;
readonly elseConstant: IConstant<Constant.KeywordConstant.Else>;
readonly falseExpression: TExpression;

@@ -227,3 +227,3 @@ }

readonly isLeaf: false;
readonly functionConstant: IConstant<Constant.PrimitiveTypeConstantKind.Function>;
readonly functionConstant: IConstant<Constant.PrimitiveTypeConstant.Function>;
readonly parameters: IParameterList<AsType>;

@@ -234,3 +234,3 @@ readonly functionReturnType: AsType;

}
export interface NullableType extends IPairedConstant<NodeKind.NullableType, Constant.LanguageConstantKind.Nullable, TType> {
export interface NullableType extends IPairedConstant<NodeKind.NullableType, Constant.LanguageConstant.Nullable, TType> {
}

@@ -245,6 +245,6 @@ export interface RecordType extends INode {

readonly isLeaf: false;
readonly tableConstant: IConstant<Constant.PrimitiveTypeConstantKind.Table>;
readonly tableConstant: IConstant<Constant.PrimitiveTypeConstant.Table>;
readonly rowType: FieldSpecificationList | TPrimaryExpression;
}
export interface ErrorRaisingExpression extends IPairedConstant<NodeKind.ErrorRaisingExpression, Constant.KeywordConstantKind.Error, TExpression> {
export interface ErrorRaisingExpression extends IPairedConstant<NodeKind.ErrorRaisingExpression, Constant.KeywordConstant.Error, TExpression> {
}

@@ -254,7 +254,7 @@ export interface ErrorHandlingExpression extends INode {

readonly isLeaf: false;
readonly tryConstant: IConstant<Constant.KeywordConstantKind.Try>;
readonly tryConstant: IConstant<Constant.KeywordConstant.Try>;
readonly protectedExpression: TExpression;
readonly maybeOtherwiseExpression: OtherwiseExpression | undefined;
}
export interface OtherwiseExpression extends IPairedConstant<NodeKind.OtherwiseExpression, Constant.KeywordConstantKind.Otherwise, TExpression> {
export interface OtherwiseExpression extends IPairedConstant<NodeKind.OtherwiseExpression, Constant.KeywordConstant.Otherwise, TExpression> {
}

@@ -267,3 +267,3 @@ export interface RecursivePrimaryExpression extends INode {

}
export interface TypePrimaryType extends IPairedConstant<NodeKind.TypePrimaryType, Constant.KeywordConstantKind.Type, TPrimaryType> {
export interface TypePrimaryType extends IPairedConstant<NodeKind.TypePrimaryType, Constant.KeywordConstant.Type, TPrimaryType> {
}

@@ -286,3 +286,3 @@ export declare type TAnyLiteral = ListLiteral | LiteralExpression | RecordLiteral;

readonly node: T;
readonly maybeCommaConstant: IConstant<Constant.MiscConstantKind.Comma> | undefined;
readonly maybeCommaConstant: IConstant<Constant.MiscConstant.Comma> | undefined;
}

@@ -292,6 +292,6 @@ export interface IKeyValuePair<Kind extends TKeyValuePairNodeKind, Key, Value> extends INode {

readonly key: Key;
readonly equalConstant: IConstant<Constant.MiscConstantKind.Equal>;
readonly equalConstant: IConstant<Constant.MiscConstant.Equal>;
readonly value: Value;
}
export interface IPairedConstant<Kind extends TPairedConstantNodeKind, ConstantKind extends Constant.TConstantKind, Paired> extends INode {
export interface IPairedConstant<Kind extends TPairedConstantNodeKind, ConstantKind extends Constant.TConstant, Paired> extends INode {
readonly kind: Kind;

@@ -301,3 +301,3 @@ readonly constant: IConstant<ConstantKind>;

}
export interface IWrapped<Kind extends TWrappedNodeKind, Open extends Constant.WrapperConstantKind, Content, Close extends Constant.WrapperConstantKind> extends INode {
export interface IWrapped<Kind extends TWrappedNodeKind, Open extends Constant.WrapperConstant, Content, Close extends Constant.WrapperConstant> extends INode {
readonly kind: Kind;

@@ -308,10 +308,10 @@ readonly openWrapperConstant: IConstant<Open>;

}
export interface IBraceWrapped<Kind extends TWrappedNodeKind, Content> extends IWrapped<Kind, Constant.WrapperConstantKind.LeftBrace, Content, Constant.WrapperConstantKind.RightBrace> {
export interface IBraceWrapped<Kind extends TWrappedNodeKind, Content> extends IWrapped<Kind, Constant.WrapperConstant.LeftBrace, Content, Constant.WrapperConstant.RightBrace> {
}
export interface IBracketWrapped<Kind extends TWrappedNodeKind, Content> extends IWrapped<Kind, Constant.WrapperConstantKind.LeftBracket, Content, Constant.WrapperConstantKind.RightBracket> {
export interface IBracketWrapped<Kind extends TWrappedNodeKind, Content> extends IWrapped<Kind, Constant.WrapperConstant.LeftBracket, Content, Constant.WrapperConstant.RightBracket> {
}
export interface IParenthesisWrapped<Kind extends TWrappedNodeKind, Content> extends IWrapped<Kind, Constant.WrapperConstantKind.LeftParenthesis, Content, Constant.WrapperConstantKind.RightParenthesis> {
export interface IParenthesisWrapped<Kind extends TWrappedNodeKind, Content> extends IWrapped<Kind, Constant.WrapperConstant.LeftParenthesis, Content, Constant.WrapperConstant.RightParenthesis> {
}
export declare type TBinOpExpression = ArithmeticExpression | AsExpression | EqualityExpression | IsExpression | LogicalExpression | MetadataExpression | NullCoalescingExpression | RelationalExpression | TBinOpExpressionSubtype;
export declare type TBinOpExpressionSubtype = IBinOpExpression<NodeKind.AsExpression, TNullablePrimitiveType, Constant.KeywordConstantKind.As, TNullablePrimitiveType> | IBinOpExpression<NodeKind.IsExpression, TNullablePrimitiveType, Constant.KeywordConstantKind.Is, TNullablePrimitiveType>;
export declare type TBinOpExpressionSubtype = IBinOpExpression<NodeKind.AsExpression, TNullablePrimitiveType, Constant.KeywordConstant.As, TNullablePrimitiveType> | IBinOpExpression<NodeKind.IsExpression, TNullablePrimitiveType, Constant.KeywordConstant.Is, TNullablePrimitiveType>;
export interface IBinOpExpression<Kind extends TBinOpExpressionNodeKind, Left, OperatorKind extends Constant.TBinOpExpressionOperator, Right> extends INode {

@@ -323,13 +323,13 @@ readonly kind: Kind;

}
export interface ArithmeticExpression extends IBinOpExpression<NodeKind.ArithmeticExpression, TArithmeticExpression, Constant.ArithmeticOperatorKind, TArithmeticExpression> {
export interface ArithmeticExpression extends IBinOpExpression<NodeKind.ArithmeticExpression, TArithmeticExpression, Constant.ArithmeticOperator, TArithmeticExpression> {
}
export interface AsExpression extends IBinOpExpression<NodeKind.AsExpression, TEqualityExpression, Constant.KeywordConstantKind.As, TNullablePrimitiveType> {
export interface AsExpression extends IBinOpExpression<NodeKind.AsExpression, TEqualityExpression, Constant.KeywordConstant.As, TNullablePrimitiveType> {
}
export interface EqualityExpression extends IBinOpExpression<NodeKind.EqualityExpression, TEqualityExpression, Constant.EqualityOperatorKind, TEqualityExpression> {
export interface EqualityExpression extends IBinOpExpression<NodeKind.EqualityExpression, TEqualityExpression, Constant.EqualityOperator, TEqualityExpression> {
}
export interface IsExpression extends IBinOpExpression<NodeKind.IsExpression, TAsExpression, Constant.KeywordConstantKind.Is, TNullablePrimitiveType> {
export interface IsExpression extends IBinOpExpression<NodeKind.IsExpression, TAsExpression, Constant.KeywordConstant.Is, TNullablePrimitiveType> {
}
export interface LogicalExpression extends IBinOpExpression<NodeKind.LogicalExpression, TLogicalExpression, Constant.LogicalOperatorKind, TLogicalExpression> {
export interface LogicalExpression extends IBinOpExpression<NodeKind.LogicalExpression, TLogicalExpression, Constant.LogicalOperator, TLogicalExpression> {
}
export interface RelationalExpression extends IBinOpExpression<NodeKind.RelationalExpression, TRelationalExpression, Constant.RelationalOperatorKind, TRelationalExpression> {
export interface RelationalExpression extends IBinOpExpression<NodeKind.RelationalExpression, TRelationalExpression, Constant.RelationalOperator, TRelationalExpression> {
}

@@ -348,11 +348,11 @@ export interface GeneralizedIdentifierPairedAnyLiteral extends IKeyValuePair<NodeKind.GeneralizedIdentifierPairedAnyLiteral, GeneralizedIdentifier, TAnyLiteral> {

readonly isLeaf: false;
readonly maybeOptionalConstant: IConstant<Constant.LanguageConstantKind.Optional> | undefined;
readonly maybeOptionalConstant: IConstant<Constant.LanguageConstant.Optional> | undefined;
readonly name: Identifier;
readonly maybeParameterType: T;
}
export interface AsNullablePrimitiveType extends IPairedConstant<NodeKind.AsNullablePrimitiveType, Constant.KeywordConstantKind.As, TNullablePrimitiveType> {
export interface AsNullablePrimitiveType extends IPairedConstant<NodeKind.AsNullablePrimitiveType, Constant.KeywordConstant.As, TNullablePrimitiveType> {
}
export interface AsType extends IPairedConstant<NodeKind.AsType, Constant.KeywordConstantKind.As, TType> {
export interface AsType extends IPairedConstant<NodeKind.AsType, Constant.KeywordConstant.As, TType> {
}
export interface IConstant<ConstantKind extends Constant.TConstantKind> extends INode {
export interface IConstant<ConstantKind extends Constant.TConstant> extends INode {
readonly kind: NodeKind.Constant;

@@ -362,5 +362,5 @@ readonly isLeaf: true;

}
export declare type TConstant = IConstant<Constant.TConstantKind>;
export declare type TConstant = IConstant<Constant.TConstant>;
export declare type TNullCoalescingExpression = NullCoalescingExpression | TLogicalExpression;
export interface NullCoalescingExpression extends IBinOpExpression<NodeKind.NullCoalescingExpression, TLogicalExpression, Constant.MiscConstantKind.NullCoalescingOperator, TLogicalExpression> {
export interface NullCoalescingExpression extends IBinOpExpression<NodeKind.NullCoalescingExpression, TLogicalExpression, Constant.MiscConstant.NullCoalescingOperator, TLogicalExpression> {
}

@@ -370,3 +370,3 @@ export interface FieldSpecification extends INode {

readonly isLeaf: false;
readonly maybeOptionalConstant: IConstant<Constant.LanguageConstantKind.Optional> | undefined;
readonly maybeOptionalConstant: IConstant<Constant.LanguageConstant.Optional> | undefined;
readonly name: GeneralizedIdentifier;

@@ -376,7 +376,7 @@ readonly maybeFieldTypeSpecification: FieldTypeSpecification | undefined;

export interface FieldSpecificationList extends IBracketWrapped<NodeKind.FieldSpecificationList, ICsvArray<FieldSpecification>> {
readonly maybeOpenRecordMarkerConstant: IConstant<Constant.MiscConstantKind.Ellipsis> | undefined;
readonly maybeOpenRecordMarkerConstant: IConstant<Constant.MiscConstant.Ellipsis> | undefined;
}
export interface FieldTypeSpecification extends INode {
readonly kind: NodeKind.FieldTypeSpecification;
readonly equalConstant: IConstant<Constant.MiscConstantKind.Equal>;
readonly equalConstant: IConstant<Constant.MiscConstant.Equal>;
readonly fieldType: TType;

@@ -383,0 +383,0 @@ }

4

lib/powerquery-parser/language/ast/astUtils/astUtils.d.ts

@@ -6,3 +6,3 @@ import { Ast } from "..";

readonly isNullable: boolean;
readonly primitiveTypeConstantKind: Constant.PrimitiveTypeConstantKind;
readonly primitiveTypeConstantKind: Constant.PrimitiveTypeConstant;
}

@@ -12,2 +12,2 @@ export declare function maybeLiteralKindFrom(maybeTokenKind: TokenKind | undefined): Ast.LiteralKind.Numeric | Ast.LiteralKind.Logical | Ast.LiteralKind.Null | Ast.LiteralKind.Text | undefined;

export declare function simplifyAsNullablePrimitiveType(node: Ast.AsNullablePrimitiveType): SimplifiedType;
export declare function primitiveTypeConstantKindFrom(node: Ast.AsNullablePrimitiveType | Ast.NullablePrimitiveType | Ast.PrimitiveType): Constant.PrimitiveTypeConstantKind;
export declare function primitiveTypeConstantKindFrom(node: Ast.AsNullablePrimitiveType | Ast.NullablePrimitiveType | Ast.PrimitiveType): Constant.PrimitiveTypeConstant;

41

lib/powerquery-parser/language/constant/constant.d.ts

@@ -1,8 +0,8 @@

export declare type TConstantKind = ArithmeticOperatorKind | EqualityOperatorKind | KeywordConstantKind | LanguageConstantKind | LogicalOperatorKind | MiscConstantKind | PrimitiveTypeConstantKind | RelationalOperatorKind | UnaryOperatorKind | WrapperConstantKind;
export declare type TBinOpExpressionOperator = ArithmeticOperatorKind | EqualityOperatorKind | LogicalOperatorKind | RelationalOperatorKind | MiscConstantKind.NullCoalescingOperator | KeywordConstantKind.As | KeywordConstantKind.Is | KeywordConstantKind.Meta;
export declare const enum LanguageConstantKind {
export declare type TConstant = ArithmeticOperator | EqualityOperator | KeywordConstant | LanguageConstant | LogicalOperator | MiscConstant | PrimitiveTypeConstant | RelationalOperator | UnaryOperator | WrapperConstant;
export declare type TBinOpExpressionOperator = ArithmeticOperator | EqualityOperator | LogicalOperator | RelationalOperator | MiscConstant.NullCoalescingOperator | KeywordConstant.As | KeywordConstant.Is | KeywordConstant.Meta;
export declare const enum LanguageConstant {
Nullable = "nullable",
Optional = "optional"
}
export declare const enum KeywordConstantKind {
export declare const enum KeywordConstant {
As = "as",

@@ -26,3 +26,3 @@ Each = "each",

}
export declare const enum MiscConstantKind {
export declare const enum MiscConstant {
Ampersand = "&",

@@ -39,3 +39,3 @@ AtSign = "@",

}
export declare const enum PrimitiveTypeConstantKind {
export declare const enum PrimitiveTypeConstant {
Action = "action",

@@ -61,3 +61,3 @@ Any = "any",

}
export declare const enum WrapperConstantKind {
export declare const enum WrapperConstant {
LeftBrace = "{",

@@ -70,3 +70,3 @@ LeftBracket = "[",

}
export declare const enum ArithmeticOperatorKind {
export declare const enum ArithmeticOperator {
Multiplication = "*",

@@ -78,11 +78,11 @@ Division = "/",

}
export declare const enum EqualityOperatorKind {
export declare const enum EqualityOperator {
EqualTo = "=",
NotEqualTo = "<>"
}
export declare const enum LogicalOperatorKind {
export declare const enum LogicalOperator {
And = "and",
Or = "or"
}
export declare const enum RelationalOperatorKind {
export declare const enum RelationalOperator {
LessThan = "<",

@@ -93,3 +93,3 @@ LessThanEqualTo = "<=",

}
export declare const enum UnaryOperatorKind {
export declare const enum UnaryOperator {
Positive = "+",

@@ -99,7 +99,12 @@ Negative = "-",

}
export declare const ArithmeticOperatorKinds: ReadonlyArray<ArithmeticOperatorKind>;
export declare const EqualityOperatorKinds: ReadonlyArray<EqualityOperatorKind>;
export declare const LogicalOperatorKinds: ReadonlyArray<LogicalOperatorKind>;
export declare const PrimitiveTypeConstantKinds: ReadonlyArray<PrimitiveTypeConstantKind>;
export declare const RelationalOperatorKinds: ReadonlyArray<RelationalOperatorKind>;
export declare const UnaryOperatorKinds: ReadonlyArray<UnaryOperatorKind>;
export declare const ArithmeticOperators: ReadonlyArray<ArithmeticOperator>;
export declare const EqualityOperators: ReadonlyArray<EqualityOperator>;
export declare const KeywordConstants: ReadonlyArray<KeywordConstant>;
export declare const LanguageConstants: ReadonlyArray<LanguageConstant>;
export declare const LogicalOperators: ReadonlyArray<LogicalOperator>;
export declare const MiscConstants: ReadonlyArray<MiscConstant>;
export declare const PrimitiveTypeConstants: ReadonlyArray<PrimitiveTypeConstant>;
export declare const RelationalOperators: ReadonlyArray<RelationalOperator>;
export declare const UnaryOperators: ReadonlyArray<UnaryOperator>;
export declare const WrapperConstants: ReadonlyArray<WrapperConstant>;
export declare const BinOpExpressionOperators: ReadonlyArray<TBinOpExpressionOperator>;

85

lib/powerquery-parser/language/constant/constant.js
"use strict";
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT license.
var __read = (this && this.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
};
var __spreadArray = (this && this.__spreadArray) || function (to, from) {
for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
to[j] = from[i];
return to;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.UnaryOperatorKinds = exports.RelationalOperatorKinds = exports.PrimitiveTypeConstantKinds = exports.LogicalOperatorKinds = exports.EqualityOperatorKinds = exports.ArithmeticOperatorKinds = void 0;
exports.BinOpExpressionOperators = exports.WrapperConstants = exports.UnaryOperators = exports.RelationalOperators = exports.PrimitiveTypeConstants = exports.MiscConstants = exports.LogicalOperators = exports.LanguageConstants = exports.KeywordConstants = exports.EqualityOperators = exports.ArithmeticOperators = void 0;
// ----------------------------------------
// ---------- const enum iterals ----------
// ----------------------------------------
exports.ArithmeticOperatorKinds = [
exports.ArithmeticOperators = [
"*" /* Multiplication */,

@@ -16,11 +37,43 @@ "/" /* Division */,

];
exports.EqualityOperatorKinds = [
exports.EqualityOperators = [
"=" /* EqualTo */,
"<>" /* NotEqualTo */,
];
exports.LogicalOperatorKinds = [
"and" /* And */,
"or" /* Or */,
exports.KeywordConstants = [
"as" /* As */,
"each" /* Each */,
"else" /* Else */,
"error" /* Error */,
"false" /* False */,
"if" /* If */,
"in" /* In */,
"is" /* Is */,
"let" /* Let */,
"meta" /* Meta */,
"otherwise" /* Otherwise */,
"section" /* Section */,
"shared" /* Shared */,
"then" /* Then */,
"true" /* True */,
"try" /* Try */,
"type" /* Type */,
];
exports.PrimitiveTypeConstantKinds = [
exports.LanguageConstants = [
"nullable" /* Nullable */,
"optional" /* Optional */,
];
exports.LogicalOperators = ["and" /* And */, "or" /* Or */];
exports.MiscConstants = [
"&" /* Ampersand */,
"@" /* AtSign */,
"," /* Comma */,
".." /* DotDot */,
"..." /* Ellipsis */,
"=" /* Equal */,
"=>" /* FatArrow */,
"??" /* NullCoalescingOperator */,
"?" /* QuestionMark */,
";" /* Semicolon */,
];
exports.PrimitiveTypeConstants = [
"action" /* Action */,

@@ -46,3 +99,3 @@ "any" /* Any */,

];
exports.RelationalOperatorKinds = [
exports.RelationalOperators = [
"<" /* LessThan */,

@@ -53,3 +106,3 @@ "<=" /* LessThanEqualTo */,

];
exports.UnaryOperatorKinds = [
exports.UnaryOperators = [
"+" /* Positive */,

@@ -59,2 +112,16 @@ "-" /* Negative */,

];
exports.WrapperConstants = [
"{" /* LeftBrace */,
"[" /* LeftBracket */,
"(" /* LeftParenthesis */,
"}" /* RightBrace */,
"]" /* RightBracket */,
")" /* RightParenthesis */,
];
exports.BinOpExpressionOperators = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(exports.ArithmeticOperators)), __read(exports.EqualityOperators)), __read(exports.LogicalOperators)), __read(exports.RelationalOperators)), [
"??" /* NullCoalescingOperator */,
"as" /* As */,
"is" /* Is */,
"meta" /* Meta */,
]);
//# sourceMappingURL=constant.js.map

25

lib/powerquery-parser/language/constant/constantUtils.d.ts
import { Constant } from ".";
import { TokenKind } from "../token";
export declare function maybeUnaryOperatorKindFrom(maybeTokenKind: TokenKind | undefined): Constant.UnaryOperatorKind | undefined;
export declare function maybeArithmeticOperatorKindFrom(maybeTokenKind: TokenKind | undefined): Constant.ArithmeticOperatorKind | undefined;
export declare function maybeEqualityOperatorKindFrom(maybeTokenKind: TokenKind | undefined): Constant.EqualityOperatorKind | undefined;
export declare function maybeLogicalOperatorKindFrom(maybeTokenKind: TokenKind | undefined): Constant.LogicalOperatorKind | undefined;
export declare function maybeRelationalOperatorKindFrom(maybeTokenKind: TokenKind | undefined): Constant.RelationalOperatorKind | undefined;
export declare function maybeUnaryOperatorKindFrom(maybeTokenKind: TokenKind | undefined): Constant.UnaryOperator | undefined;
export declare function maybeArithmeticOperatorKindFrom(maybeTokenKind: TokenKind | undefined): Constant.ArithmeticOperator | undefined;
export declare function maybeEqualityOperatorKindFrom(maybeTokenKind: TokenKind | undefined): Constant.EqualityOperator | undefined;
export declare function maybeLogicalOperatorKindFrom(maybeTokenKind: TokenKind | undefined): Constant.LogicalOperator | undefined;
export declare function maybeRelationalOperatorKindFrom(maybeTokenKind: TokenKind | undefined): Constant.RelationalOperator | undefined;
export declare function maybeBinOpExpressionOperatorKindFrom(maybeTokenKind: TokenKind | undefined): Constant.TBinOpExpressionOperator | undefined;
export declare function binOpExpressionOperatorPrecedence(operator: Constant.TBinOpExpressionOperator): number;
export declare function isPrimitiveTypeConstantKind(maybePrimitiveTypeConstantKind: string): maybePrimitiveTypeConstantKind is Constant.PrimitiveTypeConstantKind;
export declare function isPairedWrapperConstantKinds(left: Constant.TConstantKind, right: Constant.TConstantKind): boolean;
export declare function isBinOpExpressionOperator(text: string): text is Constant.TBinOpExpressionOperator;
export declare function isConstant(text: string): text is Constant.TConstant;
export declare function isArithmeticOperator(text: string): text is Constant.ArithmeticOperator;
export declare function isEqualityOperator(text: string): text is Constant.EqualityOperator;
export declare function isKeywordConstant(text: string): text is Constant.KeywordConstant;
export declare function isLanguageConstant(text: string): text is Constant.LanguageConstant;
export declare function isLogicalOperator(text: string): text is Constant.LogicalOperator;
export declare function isMiscConstant(text: string): text is Constant.MiscConstant;
export declare function isPrimitiveTypeConstant(text: string): text is Constant.PrimitiveTypeConstant;
export declare function isRelationalOperator(text: string): text is Constant.RelationalOperator;
export declare function isUnaryOperator(text: string): text is Constant.UnaryOperator;
export declare function isWrapperConstant(text: string): text is Constant.WrapperConstant;
export declare function isPairedWrapperConstantKinds(left: Constant.TConstant, right: Constant.TConstant): boolean;

95

lib/powerquery-parser/language/constant/constantUtils.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.isPairedWrapperConstantKinds = exports.isPrimitiveTypeConstantKind = exports.binOpExpressionOperatorPrecedence = exports.maybeBinOpExpressionOperatorKindFrom = exports.maybeRelationalOperatorKindFrom = exports.maybeLogicalOperatorKindFrom = exports.maybeEqualityOperatorKindFrom = exports.maybeArithmeticOperatorKindFrom = exports.maybeUnaryOperatorKindFrom = void 0;
exports.isPairedWrapperConstantKinds = exports.isWrapperConstant = exports.isUnaryOperator = exports.isRelationalOperator = exports.isPrimitiveTypeConstant = exports.isMiscConstant = exports.isLogicalOperator = exports.isLanguageConstant = exports.isKeywordConstant = exports.isEqualityOperator = exports.isArithmeticOperator = exports.isConstant = exports.isBinOpExpressionOperator = exports.binOpExpressionOperatorPrecedence = exports.maybeBinOpExpressionOperatorKindFrom = exports.maybeRelationalOperatorKindFrom = exports.maybeLogicalOperatorKindFrom = exports.maybeEqualityOperatorKindFrom = exports.maybeArithmeticOperatorKindFrom = exports.maybeUnaryOperatorKindFrom = void 0;
var _1 = require(".");
var common_1 = require("../../common");

@@ -152,36 +153,72 @@ function maybeUnaryOperatorKindFrom(maybeTokenKind) {

exports.binOpExpressionOperatorPrecedence = binOpExpressionOperatorPrecedence;
function isPrimitiveTypeConstantKind(maybePrimitiveTypeConstantKind) {
switch (maybePrimitiveTypeConstantKind) {
case "action" /* Action */:
case "any" /* Any */:
case "anynonnull" /* AnyNonNull */:
case "binary" /* Binary */:
case "date" /* Date */:
case "datetime" /* DateTime */:
case "datetimezone" /* DateTimeZone */:
case "duration" /* Duration */:
case "function" /* Function */:
case "list" /* List */:
case "logical" /* Logical */:
case "none" /* None */:
case "null" /* Null */:
case "number" /* Number */:
case "record" /* Record */:
case "table" /* Table */:
case "text" /* Text */:
case "time" /* Time */:
case "type" /* Type */:
return true;
default:
return false;
}
function isBinOpExpressionOperator(text) {
return (isArithmeticOperator(text) ||
isEqualityOperator(text) ||
isLogicalOperator(text) ||
isRelationalOperator(text) ||
text === "??" /* NullCoalescingOperator */ ||
text === "as" /* As */ ||
text === "is" /* Is */ ||
text === "meta" /* Meta */);
}
exports.isPrimitiveTypeConstantKind = isPrimitiveTypeConstantKind;
exports.isBinOpExpressionOperator = isBinOpExpressionOperator;
function isConstant(text) {
return (isArithmeticOperator(text) ||
isEqualityOperator(text) ||
isKeywordConstant(text) ||
isLanguageConstant(text) ||
isLogicalOperator(text) ||
isMiscConstant(text) ||
isPrimitiveTypeConstant(text) ||
isRelationalOperator(text) ||
isUnaryOperator(text) ||
isWrapperConstant(text));
}
exports.isConstant = isConstant;
function isArithmeticOperator(text) {
return _1.Constant.ArithmeticOperators.includes(text);
}
exports.isArithmeticOperator = isArithmeticOperator;
function isEqualityOperator(text) {
return _1.Constant.EqualityOperators.includes(text);
}
exports.isEqualityOperator = isEqualityOperator;
function isKeywordConstant(text) {
return _1.Constant.KeywordConstants.includes(text);
}
exports.isKeywordConstant = isKeywordConstant;
function isLanguageConstant(text) {
return _1.Constant.LanguageConstants.includes(text);
}
exports.isLanguageConstant = isLanguageConstant;
function isLogicalOperator(text) {
return _1.Constant.LogicalOperators.includes(text);
}
exports.isLogicalOperator = isLogicalOperator;
function isMiscConstant(text) {
return _1.Constant.MiscConstants.includes(text);
}
exports.isMiscConstant = isMiscConstant;
function isPrimitiveTypeConstant(text) {
return _1.Constant.PrimitiveTypeConstants.includes(text);
}
exports.isPrimitiveTypeConstant = isPrimitiveTypeConstant;
function isRelationalOperator(text) {
return _1.Constant.RelationalOperators.includes(text);
}
exports.isRelationalOperator = isRelationalOperator;
function isUnaryOperator(text) {
return _1.Constant.UnaryOperators.includes(text);
}
exports.isUnaryOperator = isUnaryOperator;
function isWrapperConstant(text) {
return _1.Constant.WrapperConstants.includes(text);
}
exports.isWrapperConstant = isWrapperConstant;
function isPairedWrapperConstantKinds(left, right) {
return ((left === "{" /* LeftBrace */ && right === "}" /* RightBrace */) ||
(left === "[" /* LeftBracket */ && right === "]" /* RightBracket */) ||
(left === "(" /* LeftParenthesis */ &&
right === ")" /* RightParenthesis */));
(left === "(" /* LeftParenthesis */ && right === ")" /* RightParenthesis */));
}
exports.isPairedWrapperConstantKinds = isPairedWrapperConstantKinds;
//# sourceMappingURL=constantUtils.js.map

1

lib/powerquery-parser/language/type/typeUtils/isCompatible.js

@@ -94,2 +94,3 @@ "use strict";

left.kind === "Any" /* Any */ ||
(left.kind === "Null" /* Null */ && right.isNullable) ||
left.kind === right.maybeType);

@@ -96,0 +97,0 @@ }

4

lib/powerquery-parser/language/type/typeUtils/primitive.d.ts
import { Type } from "..";
import { Constant } from "../../constant";
export declare function maybePrimitiveTypeConstantKindFromTypeKind(typeKind: Type.TypeKind): Constant.PrimitiveTypeConstantKind | undefined;
export declare function typeKindFromPrimitiveTypeConstantKind(primitiveTypeConstantKind: Constant.PrimitiveTypeConstantKind): Type.TypeKind;
export declare function maybePrimitiveTypeConstantKindFromTypeKind(typeKind: Type.TypeKind): Constant.PrimitiveTypeConstant | undefined;
export declare function typeKindFromPrimitiveTypeConstantKind(primitiveTypeConstantKind: Constant.PrimitiveTypeConstant): Type.TypeKind;
export declare const PrimitiveTypeConstantMap: ReadonlyMap<string, Type.TPrimitiveType>;
export declare function primitiveTypeMapKey(isNullable: boolean, typeKind: Type.TypeKind): string;

2

lib/powerquery-parser/parser/nodeIdMap/nodeIdMapUtils/leafSelectors.js

@@ -31,3 +31,3 @@ "use strict";

function assertUnboxLeftMostLeaf(nodeIdMapCollection, nodeId) {
return __1.XorNodeUtils.asserUnboxAst(common_1.Assert.asDefined(maybeLeftMostXor(nodeIdMapCollection, nodeId), "nodeId does not exist in nodeIdMapCollection", { nodeId: nodeId }));
return __1.XorNodeUtils.assertUnboxAst(common_1.Assert.asDefined(maybeLeftMostXor(nodeIdMapCollection, nodeId), "nodeId does not exist in nodeIdMapCollection", { nodeId: nodeId }));
}

@@ -34,0 +34,0 @@ exports.assertUnboxLeftMostLeaf = assertUnboxLeftMostLeaf;

2

lib/powerquery-parser/parser/nodeIdMap/xorNodeUtils.d.ts

@@ -28,3 +28,3 @@ import { ParseContext } from "..";

export declare function assertIsParameter(xorNode: TXorNode): asserts xorNode is XorNode<Ast.TParameter>;
export declare function asserUnboxAst(xorNode: TXorNode): Ast.TNode;
export declare function assertUnboxAst(xorNode: TXorNode): Ast.TNode;
export declare function assertUnboxAstChecked<T extends Ast.TNode>(xorNode: TXorNode, expectedNodeKinds: ReadonlyArray<T["kind"]> | T["kind"]): T;

@@ -31,0 +31,0 @@ export declare function assertUnboxContext(xorNode: TXorNode): ParseContext.TNode;

8

lib/powerquery-parser/parser/nodeIdMap/xorNodeUtils.js

@@ -5,3 +5,3 @@ "use strict";

Object.defineProperty(exports, "__esModule", { value: true });
exports.maybeUnboxAstChecked = exports.maybeUnboxAst = exports.maybeIdentifierExpressionLiteral = exports.isTWrapped = exports.isNodeKind = exports.isContextXorChecked = exports.isContextXor = exports.isAstXorChecked = exports.isAstXor = exports.assertUnboxContextChecked = exports.assertUnboxContext = exports.assertUnboxAstChecked = exports.asserUnboxAst = exports.assertIsParameter = exports.assertIsList = exports.assertIsLetExpression = exports.assertIsInvokeExpression = exports.assertIsFieldSpecificationList = exports.assertIsRecord = exports.assertIsIdentifier = exports.assertIsContextXorChecked = exports.assertIsContextXor = exports.assertIsAstXorChecked = exports.assertIsAstXor = exports.assertIsNodeKind = exports.assertAsParameter = exports.assertAsList = exports.assertAsLetExpression = exports.assertAsInvokeExpression = exports.assertAsFunctionParameterList = exports.assertAsNodeKind = exports.isTFieldAccessExpression = exports.isTPrimaryExpression = exports.isTTypeExpression = exports.isTUnaryType = exports.boxContext = exports.boxAst = void 0;
exports.maybeUnboxAstChecked = exports.maybeUnboxAst = exports.maybeIdentifierExpressionLiteral = exports.isTWrapped = exports.isNodeKind = exports.isContextXorChecked = exports.isContextXor = exports.isAstXorChecked = exports.isAstXor = exports.assertUnboxContextChecked = exports.assertUnboxContext = exports.assertUnboxAstChecked = exports.assertUnboxAst = exports.assertIsParameter = exports.assertIsList = exports.assertIsLetExpression = exports.assertIsInvokeExpression = exports.assertIsFieldSpecificationList = exports.assertIsRecord = exports.assertIsIdentifier = exports.assertIsContextXorChecked = exports.assertIsContextXor = exports.assertIsAstXorChecked = exports.assertIsAstXor = exports.assertIsNodeKind = exports.assertAsParameter = exports.assertAsList = exports.assertAsLetExpression = exports.assertAsInvokeExpression = exports.assertAsFunctionParameterList = exports.assertAsNodeKind = exports.isTFieldAccessExpression = exports.isTPrimaryExpression = exports.isTTypeExpression = exports.isTUnaryType = exports.boxContext = exports.boxAst = void 0;
var common_1 = require("../../common");

@@ -151,9 +151,9 @@ var language_1 = require("../../language");

exports.assertIsParameter = assertIsParameter;
function asserUnboxAst(xorNode) {
function assertUnboxAst(xorNode) {
assertIsAstXor(xorNode);
return xorNode.node;
}
exports.asserUnboxAst = asserUnboxAst;
exports.assertUnboxAst = assertUnboxAst;
function assertUnboxAstChecked(xorNode, expectedNodeKinds) {
var astNode = asserUnboxAst(xorNode);
var astNode = assertUnboxAst(xorNode);
language_1.AstUtils.assertIsNodeKind(astNode, expectedNodeKinds);

@@ -160,0 +160,0 @@ return astNode;

4

lib/powerquery-parser/parser/parsers/naive.d.ts

@@ -65,3 +65,3 @@ import { ParseError } from "..";

export declare function readToken(state: ParseState): string;
export declare function readTokenKindAsConstant<ConstantKind extends Constant.TConstantKind>(state: ParseState, tokenKind: Token.TokenKind, constantKind: ConstantKind): Ast.TConstant & Ast.IConstant<ConstantKind>;
export declare function maybeReadTokenKindAsConstant<ConstantKind extends Constant.TConstantKind>(state: ParseState, tokenKind: Token.TokenKind, constantKind: ConstantKind): (Ast.TConstant & Ast.IConstant<ConstantKind>) | undefined;
export declare function readTokenKindAsConstant<ConstantKind extends Constant.TConstant>(state: ParseState, tokenKind: Token.TokenKind, constantKind: ConstantKind): Ast.TConstant & Ast.IConstant<ConstantKind>;
export declare function maybeReadTokenKindAsConstant<ConstantKind extends Constant.TConstant>(state: ParseState, tokenKind: Token.TokenKind, constantKind: ConstantKind): (Ast.TConstant & Ast.IConstant<ConstantKind>) | undefined;

2

lib/powerquery-parser/parser/parseState/parseStateUtils.d.ts

@@ -15,3 +15,3 @@ import { ParseError } from "..";

export declare function isOnTokenKind(state: ParseState, tokenKind: Token.TokenKind, tokenIndex?: number): boolean;
export declare function isOnConstantKind(state: ParseState, constantKind: Constant.TConstantKind): boolean;
export declare function isOnConstantKind(state: ParseState, constantKind: Constant.TConstant): boolean;
export declare function isOnGeneralizedIdentifierStart(state: ParseState, tokenIndex?: number): boolean;

@@ -18,0 +18,0 @@ export declare function isRecursivePrimaryExpressionNext(state: ParseState, tokenIndexStart?: number): boolean;

2

package.json
{
"name": "@microsoft/powerquery-parser",
"version": "0.4.16",
"version": "0.4.17",
"description": "A parser for the Power Query/M formula language.",

@@ -5,0 +5,0 @@ "author": "Microsoft",

lib/powerquery-parser/language/ast/astUtils/astUtils.js.map

Sorry, the diff of this file is not supported yet

lib/powerquery-parser/language/constant/constant.js.map

Sorry, the diff of this file is not supported yet

lib/powerquery-parser/language/constant/constantUtils.js.map

Sorry, the diff of this file is not supported yet

lib/powerquery-parser/language/type/typeUtils/isCompatible.js.map

Sorry, the diff of this file is not supported yet

lib/powerquery-parser/language/type/typeUtils/nameOf.js.map

Sorry, the diff of this file is not supported yet

lib/powerquery-parser/language/type/typeUtils/primitive.js.map

Sorry, the diff of this file is not supported yet

lib/powerquery-parser/parser/disambiguation/disambiguationUtils.js.map

Sorry, the diff of this file is not supported yet

lib/powerquery-parser/parser/nodeIdMap/nodeIdMapUtils/leafSelectors.js.map

Sorry, the diff of this file is not supported yet

lib/powerquery-parser/parser/nodeIdMap/xorNodeUtils.js.map

Sorry, the diff of this file is not supported yet

lib/powerquery-parser/parser/parsers/combinatorialParser.js.map

Sorry, the diff of this file is not supported yet

lib/powerquery-parser/parser/parsers/naive.js

Sorry, the diff of this file is too big to display

lib/powerquery-parser/parser/parsers/naive.js.map

Sorry, the diff of this file is not supported yet

lib/powerquery-parser/parser/parseState/parseStateUtils.js.map

Sorry, the diff of this file is not supported yet