@dbml/parse 3.12.0 → 3.13.0-alpha.0

package/dist/lib/analyzer/binder/binder.d.ts

@@ -1,9 +1,10 @@
 import { CompileError } from '../../errors';
 import { ProgramNode } from '../../parser/nodes';
 import { default as Report } from '../../report';
+import { default as SymbolFactory } from '../symbol/factory';
 export default class Binder {
     private ast;
     private errors;
     constructor(ast: ProgramNode);
-    resolve(): Report<ProgramNode, CompileError>;
+    resolve(symbolFactory: SymbolFactory): Report<ProgramNode, CompileError>;
 }

package/dist/lib/analyzer/binder/elementBinder/elementBinder.d.ts

@@ -1,9 +1,11 @@
 import { ElementDeclarationNode, SyntaxNode } from '../../../parser/nodes';
-import { ArgumentBinderRule, SettingListBinderRule } from '../types';
+import { ArgumentBinderRule, InjectionBinderRule, SettingListBinderRule } from '../types';
 import { CompileError } from '../../../errors';
+import { default as SymbolFactory } from '../../symbol/factory';
 export default abstract class ElementBinder {
     protected abstract subfield: {
         arg: ArgumentBinderRule;
+        injection?: InjectionBinderRule;
         settingList: SettingListBinderRule;
     };
     protected abstract settingList: SettingListBinderRule;
@@ -14,8 +16,10 @@ export default abstract class ElementBinder {
     private bindSettingList;
     private bindBody;
     private bindSubfield;
+    private bindPartialInjection;
     private scanAndBind;
     private bindFragments;
     private resolveIndexStack;
     protected logError(node: SyntaxNode, message: string, ignoreError: boolean): void;
+    resolveInjections(symbolFactory: SymbolFactory): void;
 }

package/dist/lib/analyzer/binder/elementBinder/table.d.ts

@@ -15,6 +15,14 @@ export default class TableBinder extends ElementBinder {
                 ignoreNameNotFound: boolean;
             })[];
         };
+        injection: {
+            injectionBinderRule: {
+                shouldBind: true;
+                topSubnamesSymbolKind: never[];
+                remainingSubnamesSymbolKind: SymbolKind;
+                ignoreNameNotFound: boolean;
+            };
+        };
         settingList: {
             ref: {
                 shouldBind: true;

package/dist/lib/analyzer/binder/elementBinder/tablePartial.d.ts

@@ -0,0 +1,31 @@
+import { SymbolKind } from '../../symbol/symbolIndex';
+import { default as ElementBinder } from './elementBinder';
+export default class TablePartialBinder extends ElementBinder {
+    protected subfield: {
+        arg: {
+            argBinderRules: ({
+                shouldBind: false;
+                topSubnamesSymbolKind?: undefined;
+                remainingSubnamesSymbolKind?: undefined;
+                ignoreNameNotFound?: undefined;
+            } | {
+                shouldBind: true;
+                topSubnamesSymbolKind: SymbolKind[];
+                remainingSubnamesSymbolKind: SymbolKind;
+                ignoreNameNotFound: boolean;
+            })[];
+        };
+        settingList: {
+            ref: {
+                shouldBind: true;
+                topSubnamesSymbolKind: SymbolKind[];
+                remainingSubnamesSymbolKind: SymbolKind;
+                ignoreNameNotFound: boolean;
+            };
+            default: {
+                shouldBind: false;
+            };
+        };
+    };
+    protected settingList: {};
+}

package/dist/lib/analyzer/binder/types.d.ts

@@ -14,3 +14,6 @@ export interface ArgumentBinderRule {
 export interface SettingListBinderRule {
     [index: string]: BinderRule;
 }
+export interface InjectionBinderRule {
+    injectionBinderRule: BinderRule;
+}

package/dist/lib/analyzer/binder/utils.d.ts

@@ -8,6 +8,7 @@ import { default as ProjectBinder } from './elementBinder/project';
 import { default as RefBinder } from './elementBinder/ref';
 import { default as TableBinder } from './elementBinder/table';
 import { default as TableGroupBinder } from './elementBinder/tableGroup';
+import { default as TablePartialBinder } from './elementBinder/tablePartial';
 export declare function pickBinder(element: ElementDeclarationNode & {
     type: SyntaxToken;
-}): typeof EnumBinder | typeof TableBinder | typeof TableGroupBinder | typeof ProjectBinder | typeof RefBinder | typeof NoteBinder | typeof IndexesBinder | typeof CustomBinder;
+}): typeof EnumBinder | typeof TableBinder | typeof TableGroupBinder | typeof ProjectBinder | typeof RefBinder | typeof NoteBinder | typeof IndexesBinder | typeof TablePartialBinder | typeof CustomBinder;

package/dist/lib/analyzer/symbol/symbolIndex.d.ts

@@ -8,7 +8,9 @@ export declare enum SymbolKind {
     TableGroupField = "TableGroup field",
     Enum = "Enum",
     EnumField = "Enum field",
-    Note = "Note"
+    Note = "Note",
+    TablePartial = "TablePartial",
+    TablePartialInjection = "TablePartialInjection"
 }
 export declare function createSchemaSymbolIndex(key: string): NodeSymbolIndex;
 export declare function createTableSymbolIndex(key: string): NodeSymbolIndex;
@@ -18,9 +20,13 @@ export declare function createEnumFieldSymbolIndex(key: string): NodeSymbolIndex
 export declare function createTableGroupSymbolIndex(key: string): NodeSymbolIndex;
 export declare function createTableGroupFieldSymbolIndex(key: string): NodeSymbolIndex;
 export declare function createStickyNoteSymbolIndex(key: string): NodeSymbolIndex;
+export declare function createTablePartialSymbolIndex(key: string): NodeSymbolIndex;
+export declare function createTablePartialInjectionSymbolIndex(key: string): NodeSymbolIndex;
 export declare function createNodeSymbolIndex(key: string, symbolKind: SymbolKind): NodeSymbolIndex;
 export declare function destructureIndex(id: NodeSymbolIndex): Option<{
     name: string;
     kind: SymbolKind;
 }>;
 export declare function isPublicSchemaIndex(id: NodeSymbolIndex): boolean;
+export declare function isInjectionIndex(id: NodeSymbolIndex): boolean;
+export declare function getInjectorIndex(injectionNodeIndex: NodeSymbolIndex): NodeSymbolIndex | null;

package/dist/lib/analyzer/symbol/symbolTable.d.ts

@@ -8,4 +8,5 @@ export default class SymbolTable {
     get(id: NodeSymbolIndex): NodeSymbol | undefined;
     get(id: NodeSymbolIndex, defaultValue: NodeSymbol): NodeSymbol;
     entries(): IterableIterator<[NodeSymbolIndex, NodeSymbol]>;
+    forEach(callback: (value: NodeSymbol, key: NodeSymbolIndex) => void): void;
 }

package/dist/lib/analyzer/symbol/symbols.d.ts

@@ -11,6 +11,7 @@ export interface NodeSymbol {
     symbolTable?: SymbolTable;
     declaration?: SyntaxNode;
     references: SyntaxNode[];
+    injectorId?: NodeSymbolId;
 }
 export declare class SchemaSymbol implements NodeSymbol {
     id: NodeSymbolId;
@@ -74,3 +75,29 @@ export declare class TableGroupFieldSymbol implements NodeSymbol {
         declaration: SyntaxNode;
     }, id: NodeSymbolId);
 }
+export declare class TablePartialSymbol implements NodeSymbol {
+    id: NodeSymbolId;
+    symbolTable: SymbolTable;
+    declaration: SyntaxNode;
+    references: SyntaxNode[];
+    constructor({ symbolTable, declaration }: {
+        symbolTable: SymbolTable;
+        declaration: SyntaxNode;
+    }, id: NodeSymbolId);
+}
+export declare class TablePartialInjectionSymbol implements NodeSymbol {
+    id: NodeSymbolId;
+    declaration: SyntaxNode;
+    references: SyntaxNode[];
+    constructor({ declaration }: {
+        declaration: SyntaxNode;
+    }, id: NodeSymbolId);
+}
+export declare class TablePartialInjectedColumnSymbol implements NodeSymbol {
+    id: NodeSymbolId;
+    injectorId: NodeSymbolId;
+    references: SyntaxNode[];
+    constructor({ injectorId }: {
+        injectorId: NodeSymbolId;
+    }, id: NodeSymbolId);
+}

package/dist/lib/analyzer/types.d.ts

@@ -5,5 +5,6 @@ export declare enum ElementKind {
     Note = "note",
     Project = "project",
     Indexes = "indexes",
-    TableGroup = "tablegroup"
+    TableGroup = "tablegroup",
+    TablePartial = "tablepartial"
 }

package/dist/lib/analyzer/validator/elementValidators/table.d.ts

@@ -1,6 +1,6 @@
 import { default as SymbolFactory } from '../../symbol/factory';
 import { CompileError } from '../../../errors';
-import { BlockExpressionNode, ElementDeclarationNode, ExpressionNode, FunctionApplicationNode } from '../../../parser/nodes';
+import { BlockExpressionNode, ElementDeclarationNode, ExpressionNode, FunctionApplicationNode, PartialInjectionNode } from '../../../parser/nodes';
 import { ElementValidator } from '../types';
 import { SyntaxToken } from '../../../lexer/tokens';
 import { default as SymbolTable } from '../../../analyzer/symbol/symbolTable';
@@ -19,7 +19,10 @@ export default class TableValidator implements ElementValidator {
     registerElement(): CompileError[];
     validateBody(body?: FunctionApplicationNode | BlockExpressionNode): CompileError[];
     validateFields(fields: FunctionApplicationNode[]): CompileError[];
-    registerField(field: FunctionApplicationNode): CompileError[];
-    validateFieldSetting(parts: ExpressionNode[]): CompileError[];
+    validateInjections(injections: PartialInjectionNode[]): CompileError[];
+    registerInjection(injection: PartialInjectionNode): CompileError[];
+    validateColumns(columns: FunctionApplicationNode[]): CompileError[];
+    registerColumn(field: FunctionApplicationNode): CompileError[];
+    validateColumnSetting(parts: ExpressionNode[]): CompileError[];
     private validateSubElements;
 }

package/dist/lib/analyzer/validator/elementValidators/tablePartial.d.ts

@@ -0,0 +1,25 @@
+import { default as SymbolFactory } from '../../symbol/factory';
+import { CompileError } from '../../../errors';
+import { BlockExpressionNode, ElementDeclarationNode, ExpressionNode, FunctionApplicationNode } from '../../../parser/nodes';
+import { ElementValidator } from '../types';
+import { SyntaxToken } from '../../../lexer/tokens';
+import { default as SymbolTable } from '../../symbol/symbolTable';
+export default class TablePartialValidator implements ElementValidator {
+    private declarationNode;
+    private symbolFactory;
+    private publicSymbolTable;
+    constructor(declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    }, publicSymbolTable: SymbolTable, symbolFactory: SymbolFactory);
+    validate(): CompileError[];
+    private validateContext;
+    private validateName;
+    private validateAlias;
+    private validateSettingList;
+    registerElement(): CompileError[];
+    validateBody(body?: FunctionApplicationNode | BlockExpressionNode): CompileError[];
+    validateFields(fields: FunctionApplicationNode[]): CompileError[];
+    registerField(field: FunctionApplicationNode): CompileError[];
+    validateFieldSetting(parts: ExpressionNode[]): CompileError[];
+    private validateSubElements;
+}

package/dist/lib/analyzer/validator/utils.d.ts

@@ -12,9 +12,10 @@ import { default as SymbolTable } from '../symbol/symbolTable';
 import { default as SymbolFactory } from '../symbol/factory';
 import { default as Report } from '../../report';
 import { CompileError } from '../../errors';
+import { default as TablePartialValidator } from './elementValidators/tablePartial';
 export declare function pickValidator(element: ElementDeclarationNode & {
     type: SyntaxToken;
-}): typeof CustomValidator | typeof EnumValidator | typeof TableValidator | typeof TableGroupValidator | typeof ProjectValidator | typeof RefValidator | typeof NoteValidator | typeof IndexesValidator;
+}): typeof CustomValidator | typeof EnumValidator | typeof TableValidator | typeof TableGroupValidator | typeof ProjectValidator | typeof RefValidator | typeof NoteValidator | typeof IndexesValidator | typeof TablePartialValidator;
 export declare function isValidName(nameNode: SyntaxNode): boolean;
 export declare function isValidAlias(aliasNode: SyntaxNode): aliasNode is PrimaryExpressionNode & {
     expression: VariableNode;

package/dist/lib/errors.d.ts

@@ -26,53 +26,63 @@ export declare enum CompileErrorCode {
     INVALID_TABLE_CONTEXT = 3010,
     INVALID_TABLE_SETTING = 3011,
     DUPLICATE_TABLE_SETTING = 3012,
-    INVALID_TABLEGROUP_CONTEXT = 3013,
-    INVALID_TABLEGROUP_ELEMENT_NAME = 3014,
-    DUPLICATE_TABLEGROUP_ELEMENT_NAME = 3015,
-    DUPLICATE_TABLEGROUP_FIELD_NAME = 3016,
-    INVALID_TABLEGROUP_FIELD = 3017,
-    EMPTY_TABLE = 3018,
-    INVALID_COLUMN = 3019,
-    INVALID_COLUMN_NAME = 3020,
-    UNKNOWN_COLUMN_SETTING = 3021,
-    INVALID_COLUMN_TYPE = 3022,
-    DUPLICATE_COLUMN_NAME = 3023,
-    DUPLICATE_COLUMN_SETTING = 3024,
-    INVALID_COLUMN_SETTING_VALUE = 3025,
-    INVALID_ENUM_CONTEXT = 3026,
-    INVALID_ENUM_ELEMENT_NAME = 3027,
-    INVALID_ENUM_ELEMENT = 3028,
-    DUPLICATE_ENUM_ELEMENT_NAME = 3029,
-    UNKNOWN_ENUM_ELEMENT_SETTING = 3030,
-    DUPLICATE_ENUM_ELEMENT_SETTING = 3031,
-    INVALID_ENUM_ELEMENT_SETTING = 3032,
-    EMPTY_ENUM = 3033,
-    INVALID_REF_CONTEXT = 3034,
-    UNKNOWN_REF_SETTING = 3035,
-    DUPLICATE_REF_SETTING = 3036,
-    INVALID_REF_SETTING_VALUE = 3037,
-    INVALID_REF_RELATIONSHIP = 3038,
-    INVALID_REF_FIELD = 3039,
-    EMPTY_REF = 3040,
-    REF_REDEFINED = 3041,
-    INVALID_NOTE_CONTEXT = 3042,
-    INVALID_NOTE = 3043,
-    NOTE_REDEFINED = 3044,
-    NOTE_CONTENT_REDEFINED = 3045,
-    EMPTY_NOTE = 3046,
-    INVALID_INDEXES_CONTEXT = 3047,
-    INVALID_INDEXES_FIELD = 3048,
-    INVALID_INDEX = 3049,
-    UNKNOWN_INDEX_SETTING = 3050,
-    DUPLICATE_INDEX_SETTING = 3051,
-    UNEXPECTED_INDEX_SETTING_VALUE = 3052,
-    INVALID_INDEX_SETTING_VALUE = 3053,
-    INVALID_PROJECT_CONTEXT = 3054,
-    PROJECT_REDEFINED = 3055,
-    INVALID_PROJECT_FIELD = 3056,
-    INVALID_CUSTOM_CONTEXT = 3057,
-    INVALID_CUSTOM_ELEMENT_VALUE = 3058,
-    INVALID_ELEMENT_IN_SIMPLE_BODY = 3059,
+    INVALID_TABLE_FIELD = 3013,
+    INVALID_TABLEGROUP_CONTEXT = 3014,
+    INVALID_TABLEGROUP_ELEMENT_NAME = 3015,
+    DUPLICATE_TABLEGROUP_ELEMENT_NAME = 3016,
+    DUPLICATE_TABLEGROUP_FIELD_NAME = 3017,
+    INVALID_TABLEGROUP_FIELD = 3018,
+    INVALID_TABLE_PARTIAL_CONTEXT = 3019,
+    INVALID_TABLE_PARTIAL_ELEMENT_NAME = 3020,
+    INVALID_TABLE_PARTIAL_SETTING = 3021,
+    DUPLICATE_TABLE_PARTIAL_ELEMENT_NAME = 3022,
+    DUPLICATE_TABLE_PARTIAL_SETTING = 3023,
+    INVALID_TABLE_PARTIAL_INJECTION = 3024,
+    INVALID_TABLE_PARTIAL_INJECTION_OP = 3025,
+    INVALID_TABLE_PARTIAL_INJECTION_NAME = 3026,
+    DUPLICATE_TABLE_PARTIAL_INJECTION_NAME = 3027,
+    EMPTY_TABLE = 3028,
+    INVALID_COLUMN = 3029,
+    INVALID_COLUMN_NAME = 3030,
+    UNKNOWN_COLUMN_SETTING = 3031,
+    INVALID_COLUMN_TYPE = 3032,
+    DUPLICATE_COLUMN_NAME = 3033,
+    DUPLICATE_COLUMN_SETTING = 3034,
+    INVALID_COLUMN_SETTING_VALUE = 3035,
+    INVALID_ENUM_CONTEXT = 3036,
+    INVALID_ENUM_ELEMENT_NAME = 3037,
+    INVALID_ENUM_ELEMENT = 3038,
+    DUPLICATE_ENUM_ELEMENT_NAME = 3039,
+    UNKNOWN_ENUM_ELEMENT_SETTING = 3040,
+    DUPLICATE_ENUM_ELEMENT_SETTING = 3041,
+    INVALID_ENUM_ELEMENT_SETTING = 3042,
+    EMPTY_ENUM = 3043,
+    INVALID_REF_CONTEXT = 3044,
+    UNKNOWN_REF_SETTING = 3045,
+    DUPLICATE_REF_SETTING = 3046,
+    INVALID_REF_SETTING_VALUE = 3047,
+    INVALID_REF_RELATIONSHIP = 3048,
+    INVALID_REF_FIELD = 3049,
+    EMPTY_REF = 3050,
+    REF_REDEFINED = 3051,
+    INVALID_NOTE_CONTEXT = 3052,
+    INVALID_NOTE = 3053,
+    NOTE_REDEFINED = 3054,
+    NOTE_CONTENT_REDEFINED = 3055,
+    EMPTY_NOTE = 3056,
+    INVALID_INDEXES_CONTEXT = 3057,
+    INVALID_INDEXES_FIELD = 3058,
+    INVALID_INDEX = 3059,
+    UNKNOWN_INDEX_SETTING = 3060,
+    DUPLICATE_INDEX_SETTING = 3061,
+    UNEXPECTED_INDEX_SETTING_VALUE = 3062,
+    INVALID_INDEX_SETTING_VALUE = 3063,
+    INVALID_PROJECT_CONTEXT = 3064,
+    PROJECT_REDEFINED = 3065,
+    INVALID_PROJECT_FIELD = 3066,
+    INVALID_CUSTOM_CONTEXT = 3067,
+    INVALID_CUSTOM_ELEMENT_VALUE = 3068,
+    INVALID_ELEMENT_IN_SIMPLE_BODY = 3069,
     BINDING_ERROR = 4000,
     UNSUPPORTED = 5000,
     CIRCULAR_REF = 5001,

package/dist/lib/interpreter/elementInterpreter/table.d.ts

@@ -13,6 +13,7 @@ export declare class TableInterpreter implements ElementInterpreter {
     private interpretSettingList;
     private interpretBody;
     private interpretSubElements;
+    private interpretInjection;
     private interpretFields;
     private interpretColumn;
     private interpretIndexes;

package/dist/lib/interpreter/elementInterpreter/tablePartial.d.ts

@@ -0,0 +1,18 @@
+import { ElementInterpreter, InterpreterDatabase } from '../types';
+import { ElementDeclarationNode } from '../../parser/nodes';
+import { CompileError } from '../../errors';
+export declare class TablePartialInterpreter implements ElementInterpreter {
+    private declarationNode;
+    private env;
+    private tablePartial;
+    private pkColumns;
+    constructor(declarationNode: ElementDeclarationNode, env: InterpreterDatabase);
+    interpret(): CompileError[];
+    private interpretName;
+    private interpretSettingList;
+    private interpretBody;
+    private interpretSubElements;
+    private interpretFields;
+    private interpretColumn;
+    private interpretIndexes;
+}

package/dist/lib/interpreter/types.d.ts

@@ -21,6 +21,7 @@ export interface InterpreterDatabase {
         [tableid: string]: ElementDeclarationNode;
     };
     tableGroups: Map<ElementDeclarationNode, TableGroup>;
+    tablePartials: Map<ElementDeclarationNode, TablePartial>;
     aliases: Alias[];
     project: Map<ElementDeclarationNode, Project>;
 }
@@ -33,12 +34,14 @@ export interface Database {
     tableGroups: TableGroup[];
     aliases: Alias[];
     project: Project;
+    tablePartials: TablePartial[];
 }
 export interface Table {
     name: string;
     schemaName: null | string;
     alias: string | null;
     fields: Column[];
+    partials: TablePartialInjection[];
     token: TokenPosition;
     indexes: Index[];
     headerColor?: string;
@@ -154,16 +157,33 @@ export interface Alias {
         schemaName: string | null;
     };
 }
+export interface TablePartial {
+    name: string;
+    fields: Column[];
+    token: TokenPosition;
+    indexes: Index[];
+    headerColor?: string;
+    note?: {
+        value: string;
+        token: TokenPosition;
+    };
+}
+export interface TablePartialInjection {
+    name: string;
+    order: number;
+    token: TokenPosition;
+}
 export type Project = Record<string, never> | {
     name: string | null;
     tables: Table[];
     refs: Ref[];
     enums: Enum[];
     tableGroups: TableGroup[];
+    tablePartials: TablePartial[];
     note?: {
         value: string;
         token: TokenPosition;
     };
     token: TokenPosition;
-    [index: string & Omit<any, 'name' | 'tables' | 'refs' | 'enums' | 'tableGroups' | 'note'>]: string;
+    [index: string & Omit<any, 'name' | 'tables' | 'refs' | 'enums' | 'tableGroups' | 'note' | 'tablePartials'>]: string;
 };

package/dist/lib/lexer/tokens.d.ts

@@ -22,6 +22,7 @@ export declare enum SyntaxTokenKind {
     IDENTIFIER = "<identifier>",
     SEMICOLON = "<semicolon>",
     COLON = "<colon>",
+    TILDE = "<tilde>",
     SINGLE_LINE_COMMENT = "<single-line-comment>",
     MULTILINE_COMMENT = "<multiline-comment>"
 }

package/dist/lib/parser/nodes.d.ts

@@ -39,7 +39,8 @@ export declare enum SyntaxNodeKind {
     PRIMARY_EXPRESSION = "<primary-expression>",
     GROUP_EXPRESSION = "<group-expression>",
     DUMMY = "<dummy>",
-    ARRAY = "<array>"
+    ARRAY = "<array>",
+    PARTIAL_INJECTION = "<partial-injection>"
 }
 export declare class ProgramNode extends SyntaxNode {
     body: ElementDeclarationNode[];
@@ -128,14 +129,20 @@ export declare class FunctionApplicationNode extends SyntaxNode {
 }
 export declare class BlockExpressionNode extends SyntaxNode {
     blockOpenBrace?: SyntaxToken;
-    body: (ElementDeclarationNode | FunctionApplicationNode)[];
+    body: (PartialInjectionNode | ElementDeclarationNode | FunctionApplicationNode)[];
     blockCloseBrace?: SyntaxToken;
     constructor({ blockOpenBrace, body, blockCloseBrace, }: {
         blockOpenBrace?: SyntaxToken;
-        body?: (ElementDeclarationNode | FunctionApplicationNode)[];
+        body?: (PartialInjectionNode | ElementDeclarationNode | FunctionApplicationNode)[];
         blockCloseBrace?: SyntaxToken;
     }, id: SyntaxNodeId);
 }
+export declare class PartialInjectionNode extends SyntaxNode {
+    partial?: VariableNode;
+    constructor({ partial }: {
+        partial?: VariableNode;
+    }, id: SyntaxNodeId);
+}
 export declare class ListExpressionNode extends SyntaxNode {
     listOpenBracket?: SyntaxToken;
     elementList: AttributeNode[];

package/dist/lib/parser/parser.d.ts

@@ -36,6 +36,7 @@ export default class Parser {
     private leftExpression_bp;
     private extractOperand;
     private functionExpression;
+    private variable;
     private blockExpression;
     private canBeField;
     private synchronizeBlock;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dbml/parse",
-  "version": "3.12.0",
+  "version": "3.13.0-alpha.0",
   "description": "> TODO: description",
   "author": "Holistics <dev@holistics.io>",
   "license": "Apache-2.0",
@@ -46,5 +46,5 @@
   "peerDependencies": {
     "lodash": "^4.17.21"
   },
-  "gitHead": "e14cab048ba2c38acb622e780bea160a115a03d5"
+  "gitHead": "6b6edb8bc9804cd65849451820f1d43072d8c01c"
 }