@platformos/prettier-plugin-liquid 0.0.2

package/dist/printer/utils/node.d.ts

@@ -0,0 +1,44 @@
+import { NodeTypes, Position } from '@platformos/liquid-html-parser';
+import { HtmlSelfClosingElement, LiquidHtmlNode, TextNode, LiquidNode, HtmlNode, HtmlVoidElement, HtmlComment, HtmlElement, LiquidTag, AttributeNode, HtmlDanglingMarkerClose } from '../../types';
+export declare function isScriptLikeTag(node: {
+    type: NodeTypes;
+}): boolean;
+export declare function isPreLikeNode(node: {
+    cssWhitespace: string;
+}): boolean;
+export declare function hasNoCloseMarker(node: LiquidHtmlNode): node is HtmlComment | HtmlVoidElement | HtmlSelfClosingElement | HtmlDanglingMarkerClose | HtmlElement;
+export declare function hasNoChildren(node: LiquidHtmlNode): node is HtmlComment | HtmlVoidElement | HtmlSelfClosingElement | HtmlDanglingMarkerClose;
+export declare function isHtmlDanglingMarkerOpen(node: LiquidHtmlNode): node is Omit<HtmlElement, 'blockEndPosition'> & {
+    blockEndPosition: Position;
+};
+export declare function isHtmlDanglingMarkerClose(node: LiquidHtmlNode): node is HtmlDanglingMarkerClose;
+export declare function isHtmlComment(node: LiquidHtmlNode): node is HtmlComment;
+export declare function isSelfClosing(node: LiquidHtmlNode): node is HtmlSelfClosingElement;
+export declare function isVoidElement(node: LiquidHtmlNode): node is HtmlVoidElement;
+export declare function isHtmlElement(node: LiquidHtmlNode): node is HtmlElement;
+export declare function isTextLikeNode(node: LiquidHtmlNode | undefined): node is TextNode;
+export declare function isLiquidNode(node: LiquidHtmlNode | undefined): node is LiquidNode;
+export declare function isMultilineLiquidTag(node: LiquidHtmlNode | undefined): node is LiquidTag;
+export declare function isHtmlNode(node: LiquidHtmlNode | undefined): node is HtmlNode;
+export declare function isAttributeNode(node: LiquidHtmlNode): node is AttributeNode & {
+    parentNode: HtmlNode;
+};
+export declare function hasNonTextChild(node: LiquidHtmlNode): any;
+export declare function shouldPreserveContent(node: LiquidHtmlNode): boolean;
+export declare function isPrettierIgnoreHtmlNode(node: LiquidHtmlNode | undefined): node is HtmlComment;
+export declare function isPrettierIgnoreLiquidNode(node: LiquidHtmlNode | undefined): node is LiquidTag;
+export declare function isPrettierIgnoreNode(node: LiquidHtmlNode | undefined): node is HtmlComment | LiquidTag;
+export declare function hasPrettierIgnore(node: LiquidHtmlNode): boolean;
+export declare function isPrettierIgnoreAttributeNode(node: LiquidHtmlNode | undefined): boolean;
+export declare function forceNextEmptyLine(node: LiquidHtmlNode | undefined): boolean;
+/** firstChild leadingSpaces and lastChild trailingSpaces */
+export declare function forceBreakContent(node: LiquidHtmlNode): boolean | undefined;
+/** spaces between children */
+export declare function forceBreakChildren(node: LiquidHtmlNode): boolean;
+export declare function preferHardlineAsSurroundingSpaces(node: LiquidHtmlNode): boolean | undefined;
+export declare function preferHardlineAsLeadingSpaces(node: LiquidHtmlNode): boolean;
+export declare function preferHardlineAsTrailingSpaces(node: LiquidHtmlNode): boolean;
+export declare function hasMeaningfulLackOfLeadingWhitespace(node: LiquidHtmlNode): boolean;
+export declare function hasMeaningfulLackOfTrailingWhitespace(node: LiquidHtmlNode): boolean;
+export declare function hasMeaningfulLackOfDanglingWhitespace(node: LiquidHtmlNode): boolean;
+export declare function getLastDescendant(node: LiquidHtmlNode): LiquidHtmlNode;

package/dist/printer/utils/node.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isScriptLikeTag = isScriptLikeTag;
+exports.isPreLikeNode = isPreLikeNode;
+exports.hasNoCloseMarker = hasNoCloseMarker;
+exports.hasNoChildren = hasNoChildren;
+exports.isHtmlDanglingMarkerOpen = isHtmlDanglingMarkerOpen;
+exports.isHtmlDanglingMarkerClose = isHtmlDanglingMarkerClose;
+exports.isHtmlComment = isHtmlComment;
+exports.isSelfClosing = isSelfClosing;
+exports.isVoidElement = isVoidElement;
+exports.isHtmlElement = isHtmlElement;
+exports.isTextLikeNode = isTextLikeNode;
+exports.isLiquidNode = isLiquidNode;
+exports.isMultilineLiquidTag = isMultilineLiquidTag;
+exports.isHtmlNode = isHtmlNode;
+exports.isAttributeNode = isAttributeNode;
+exports.hasNonTextChild = hasNonTextChild;
+exports.shouldPreserveContent = shouldPreserveContent;
+exports.isPrettierIgnoreHtmlNode = isPrettierIgnoreHtmlNode;
+exports.isPrettierIgnoreLiquidNode = isPrettierIgnoreLiquidNode;
+exports.isPrettierIgnoreNode = isPrettierIgnoreNode;
+exports.hasPrettierIgnore = hasPrettierIgnore;
+exports.isPrettierIgnoreAttributeNode = isPrettierIgnoreAttributeNode;
+exports.forceNextEmptyLine = forceNextEmptyLine;
+exports.forceBreakContent = forceBreakContent;
+exports.forceBreakChildren = forceBreakChildren;
+exports.preferHardlineAsSurroundingSpaces = preferHardlineAsSurroundingSpaces;
+exports.preferHardlineAsLeadingSpaces = preferHardlineAsLeadingSpaces;
+exports.preferHardlineAsTrailingSpaces = preferHardlineAsTrailingSpaces;
+exports.hasMeaningfulLackOfLeadingWhitespace = hasMeaningfulLackOfLeadingWhitespace;
+exports.hasMeaningfulLackOfTrailingWhitespace = hasMeaningfulLackOfTrailingWhitespace;
+exports.hasMeaningfulLackOfDanglingWhitespace = hasMeaningfulLackOfDanglingWhitespace;
+exports.getLastDescendant = getLastDescendant;
+const liquid_html_parser_1 = require("@platformos/liquid-html-parser");
+const array_1 = require("./array");
+function isScriptLikeTag(node) {
+    return node.type === liquid_html_parser_1.NodeTypes.HtmlRawNode;
+}
+function isPreLikeNode(node) {
+    return node.cssWhitespace.startsWith('pre');
+}
+// A bit like self-closing except we distinguish between them.
+// Comments are also considered self-closing.
+function hasNoCloseMarker(node) {
+    return hasNoChildren(node) || isHtmlDanglingMarkerOpen(node);
+}
+function hasNoChildren(node) {
+    return (isSelfClosing(node) ||
+        isVoidElement(node) ||
+        isHtmlComment(node) ||
+        isHtmlDanglingMarkerClose(node));
+}
+function isHtmlDanglingMarkerOpen(node) {
+    return (node.type === liquid_html_parser_1.NodeTypes.HtmlElement && node.blockEndPosition.start === node.blockEndPosition.end);
+}
+function isHtmlDanglingMarkerClose(node) {
+    return node.type === liquid_html_parser_1.NodeTypes.HtmlDanglingMarkerClose;
+}
+function isHtmlComment(node) {
+    return node.type === liquid_html_parser_1.NodeTypes.HtmlComment;
+}
+function isSelfClosing(node) {
+    return node.type === liquid_html_parser_1.NodeTypes.HtmlSelfClosingElement;
+}
+function isVoidElement(node) {
+    return node.type === liquid_html_parser_1.NodeTypes.HtmlVoidElement;
+}
+function isHtmlElement(node) {
+    return node.type === liquid_html_parser_1.NodeTypes.HtmlElement;
+}
+function isTextLikeNode(node) {
+    return !!node && node.type === liquid_html_parser_1.NodeTypes.TextNode;
+}
+function isLiquidNode(node) {
+    return !!node && liquid_html_parser_1.LiquidNodeTypes.includes(node.type);
+}
+function isMultilineLiquidTag(node) {
+    return !!node && node.type === liquid_html_parser_1.NodeTypes.LiquidTag && !!node.children && !(0, array_1.isEmpty)(node.children);
+}
+function isHtmlNode(node) {
+    return !!node && liquid_html_parser_1.HtmlNodeTypes.includes(node.type);
+}
+function isAttributeNode(node) {
+    return (isHtmlNode(node.parentNode) &&
+        'attributes' in node.parentNode &&
+        node.parentNode.attributes.indexOf(node) !== -1);
+}
+function hasNonTextChild(node) {
+    return (node.children &&
+        node.children.some((child) => child.type !== liquid_html_parser_1.NodeTypes.TextNode));
+}
+function shouldPreserveContent(node) {
+    // // unterminated node in ie conditional comment
+    // // e.g. <!--[if lt IE 9]><html><![endif]-->
+    // if (
+    //   node.type === "ieConditionalComment" &&
+    //   node.lastChild &&
+    //   !node.lastChild.isSelfClosing &&
+    //   !node.lastChild.endSourceSpan
+    // ) {
+    //   return true;
+    // }
+    // // incomplete html in ie conditional comment
+    // // e.g. <!--[if lt IE 9]></div><![endif]-->
+    // if (node.type === "ieConditionalComment" && !node.complete) {
+    //   return true;
+    // }
+    // TODO: Handle pre correctly?
+    if (isPreLikeNode(node)) {
+        return true;
+    }
+    return false;
+}
+function isPrettierIgnoreHtmlNode(node) {
+    return (!!node && node.type === liquid_html_parser_1.NodeTypes.HtmlComment && /^\s*prettier-ignore(?=\s|$)/m.test(node.body));
+}
+function isPrettierIgnoreLiquidNode(node) {
+    return (!!node &&
+        node.type === liquid_html_parser_1.NodeTypes.LiquidTag &&
+        node.name === '#' &&
+        /^\s*prettier-ignore(?=\s|$)/m.test(node.markup));
+}
+function isPrettierIgnoreNode(node) {
+    return isPrettierIgnoreLiquidNode(node) || isPrettierIgnoreHtmlNode(node);
+}
+function hasPrettierIgnore(node) {
+    return isPrettierIgnoreNode(node) || isPrettierIgnoreNode(node.prev);
+}
+function getPrettierIgnoreAttributeCommentData(value) {
+    const match = value.trim().match(/prettier-ignore-attribute(?:s?)(?:\s+(.+))?$/s);
+    if (!match) {
+        return false;
+    }
+    if (!match[1]) {
+        return true;
+    }
+    // TODO We should support 'prettier-ignore-attribute a,b,c' and allow users to not
+    // format the insides of some attributes.
+    //
+    // But since we don't reformat the insides of attributes yet (because of
+    // issue #4), that feature doesn't really make sense.
+    //
+    // For now, we'll only support `prettier-ignore-attribute`
+    //
+    // https://github.com/Shopify/prettier-plugin-liquid/issues/4
+    //
+    // return match[1].split(/\s+/);
+    return true;
+}
+function isPrettierIgnoreAttributeNode(node) {
+    if (!node)
+        return false;
+    if (node.type === liquid_html_parser_1.NodeTypes.HtmlComment) {
+        return getPrettierIgnoreAttributeCommentData(node.body);
+    }
+    if (node.type === liquid_html_parser_1.NodeTypes.LiquidTag && node.name === '#') {
+        return getPrettierIgnoreAttributeCommentData(node.markup);
+    }
+    return false;
+}
+function forceNextEmptyLine(node) {
+    if (!node)
+        return false;
+    if (!node.next)
+        return false;
+    const source = node.source;
+    // Current implementation: force next empty line when two consecutive
+    // lines exist between nodes.
+    let tmp;
+    tmp = source.indexOf('\n', node.position.end);
+    if (tmp === -1)
+        return false;
+    tmp = source.indexOf('\n', tmp + 1);
+    if (tmp === -1)
+        return false;
+    return tmp < node.next.position.start;
+}
+/** firstChild leadingSpaces and lastChild trailingSpaces */
+function forceBreakContent(node) {
+    return (forceBreakChildren(node) ||
+        (node.type === liquid_html_parser_1.NodeTypes.HtmlElement &&
+            node.children.length > 0 &&
+            (isTagNameIncluded(['body', 'script', 'style'], node.name) ||
+                node.children.some((child) => hasNonTextChild(child)))) ||
+        (node.firstChild &&
+            node.firstChild === node.lastChild &&
+            node.firstChild.type !== liquid_html_parser_1.NodeTypes.TextNode &&
+            hasLeadingLineBreak(node.firstChild) &&
+            (!node.lastChild.isTrailingWhitespaceSensitive || hasTrailingLineBreak(node.lastChild))));
+}
+/** spaces between children */
+function forceBreakChildren(node) {
+    return (node.type === liquid_html_parser_1.NodeTypes.HtmlElement &&
+        node.children.length > 0 &&
+        (isTagNameIncluded(['html', 'head', 'ul', 'ol', 'select'], node.name) ||
+            (node.cssDisplay.startsWith('table') && node.cssDisplay !== 'table-cell')));
+}
+function preferHardlineAsSurroundingSpaces(node) {
+    switch (node.type) {
+        // case 'ieConditionalComment':
+        case liquid_html_parser_1.NodeTypes.HtmlComment:
+            return true;
+        case liquid_html_parser_1.NodeTypes.HtmlElement:
+            return isTagNameIncluded(['script', 'select'], node.name);
+        case liquid_html_parser_1.NodeTypes.LiquidTag:
+            if ((node.prev && isTextLikeNode(node.prev)) || (node.next && isTextLikeNode(node.next))) {
+                return false;
+            }
+            return node.children && node.children.length > 0;
+    }
+    return false;
+}
+function preferHardlineAsLeadingSpaces(node) {
+    return (preferHardlineAsSurroundingSpaces(node) ||
+        (isLiquidNode(node) && node.prev && isLiquidNode(node.prev)) ||
+        (node.prev && preferHardlineAsTrailingSpaces(node.prev)) ||
+        hasSurroundingLineBreak(node));
+}
+function preferHardlineAsTrailingSpaces(node) {
+    return (preferHardlineAsSurroundingSpaces(node) ||
+        (isLiquidNode(node) && node.next && (isLiquidNode(node.next) || isHtmlNode(node.next))) ||
+        (node.type === liquid_html_parser_1.NodeTypes.HtmlElement && isTagNameIncluded(['br'], node.name)) ||
+        hasSurroundingLineBreak(node));
+}
+function hasMeaningfulLackOfLeadingWhitespace(node) {
+    return node.isLeadingWhitespaceSensitive && !node.hasLeadingWhitespace;
+}
+function hasMeaningfulLackOfTrailingWhitespace(node) {
+    return node.isTrailingWhitespaceSensitive && !node.hasTrailingWhitespace;
+}
+function hasMeaningfulLackOfDanglingWhitespace(node) {
+    return node.isDanglingWhitespaceSensitive && !node.hasDanglingWhitespace;
+}
+function hasSurroundingLineBreak(node) {
+    return hasLeadingLineBreak(node) && hasTrailingLineBreak(node);
+}
+function hasLeadingLineBreak(node) {
+    if (node.type === liquid_html_parser_1.NodeTypes.Document)
+        return false;
+    return (node.hasLeadingWhitespace &&
+        hasLineBreakInRange(node.source, node.prev
+            ? node.prev.position.end
+            : node.parentNode.blockStartPosition
+                ? node.parentNode.blockStartPosition.end
+                : node.parentNode.position.start, node.position.start));
+}
+function hasTrailingLineBreak(node) {
+    if (node.type === liquid_html_parser_1.NodeTypes.Document)
+        return false;
+    return (node.hasTrailingWhitespace &&
+        hasLineBreakInRange(node.source, node.position.end, node.next
+            ? node.next.position.start
+            : node.parentNode.blockEndPosition
+                ? node.parentNode.blockEndPosition.start
+                : node.parentNode.position.end));
+}
+function hasLineBreakInRange(source, start, end) {
+    const index = source.indexOf('\n', start);
+    return index !== -1 && index < end;
+}
+function getLastDescendant(node) {
+    return node.lastChild ? getLastDescendant(node.lastChild) : node;
+}
+function isTagNameIncluded(collection, name) {
+    if (name.length !== 1 || name[0].type !== liquid_html_parser_1.NodeTypes.TextNode)
+        return false;
+    return collection.includes(name[0].value);
+}
+//# sourceMappingURL=node.js.map

package/dist/printer/utils/string.d.ts

@@ -0,0 +1,15 @@
+import { Position } from '@platformos/liquid-html-parser';
+import { LiquidAstPath, LiquidParserOptions } from '../../types';
+export declare function isWhitespace(source: string, loc: number): boolean;
+export declare const trim: (x: string) => string;
+export declare const trimEnd: (x: string) => string;
+export declare function bodyLines(str: string): string[];
+export declare function markupLines(markup: string): string[];
+export declare function reindent(lines: string[], skipFirst?: boolean): string[];
+export declare function originallyHadLineBreaks(path: LiquidAstPath, { locStart, locEnd }: LiquidParserOptions): boolean;
+export declare function hasLineBreakInRange(source: string, locStart: number, locEnd: number): boolean;
+export declare function hasMoreThanOneNewLineBetweenNodes(source: string, prev: {
+    position: Position;
+} | undefined, next: {
+    position: Position;
+} | undefined): boolean;

package/dist/printer/utils/string.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trimEnd = exports.trim = void 0;
+exports.isWhitespace = isWhitespace;
+exports.bodyLines = bodyLines;
+exports.markupLines = markupLines;
+exports.reindent = reindent;
+exports.originallyHadLineBreaks = originallyHadLineBreaks;
+exports.hasLineBreakInRange = hasLineBreakInRange;
+exports.hasMoreThanOneNewLineBetweenNodes = hasMoreThanOneNewLineBetweenNodes;
+function isWhitespace(source, loc) {
+    if (loc < 0 || loc >= source.length)
+        return false;
+    return !!source[loc].match(/\s/);
+}
+const trim = (x) => x.trim();
+exports.trim = trim;
+const trimEnd = (x) => x.trimEnd();
+exports.trimEnd = trimEnd;
+function bodyLines(str) {
+    return str
+        .replace(/^(?: |\t)*(\r?\n)*|\s*$/g, '') // only want the meat
+        .split(/\r?\n/);
+}
+function markupLines(markup) {
+    return markup.trim().split('\n');
+}
+function reindent(lines, skipFirst = false) {
+    const minIndentLevel = lines
+        .filter((_, i) => (skipFirst ? i > 0 : true))
+        .filter((line) => line.trim().length > 0)
+        .map((line) => line.match(/^\s*/)[0].length)
+        .reduce((a, b) => Math.min(a, b), Infinity);
+    if (minIndentLevel === Infinity) {
+        return lines;
+    }
+    const indentStrip = new RegExp('^' + '\\s'.repeat(minIndentLevel));
+    return lines.map((line) => line.replace(indentStrip, '')).map(exports.trimEnd);
+}
+function originallyHadLineBreaks(path, { locStart, locEnd }) {
+    const node = path.getValue();
+    return hasLineBreakInRange(node.source, locStart(node), locEnd(node));
+}
+function hasLineBreakInRange(source, locStart, locEnd) {
+    const indexOfNewLine = source.indexOf('\n', locStart);
+    return 0 <= indexOfNewLine && indexOfNewLine < locEnd;
+}
+function hasMoreThanOneNewLineBetweenNodes(source, prev, next) {
+    if (!prev || !next)
+        return false;
+    const between = source.slice(prev.position.end, next.position.start);
+    const count = between.match(/\n/g)?.length || 0;
+    return count > 1;
+}
+//# sourceMappingURL=string.js.map

package/dist/types.d.ts

@@ -0,0 +1,85 @@
+import { Doc } from 'prettier';
+import type { AstPath } from 'prettier';
+import type { ParserOptions as ParserOptions3 } from 'prettier3';
+import * as AST from '@platformos/liquid-html-parser';
+export type CommonKeys<T1, T2> = Extract<keyof T1, keyof T2>;
+export type { AstPath };
+export type ParserOptions<T = any> = ParserOptions3<T>;
+export declare function isLiquidHtmlNode(value: any): value is LiquidHtmlNode;
+export type LiquidAstPath = AstPath<LiquidHtmlNode>;
+export type LiquidParserOptions = ParserOptions<LiquidHtmlNode> & {
+    singleAttributePerLine: boolean;
+    singleLineLinkTags: boolean;
+    liquidSingleQuote: boolean;
+    embeddedSingleQuote: boolean;
+    indentSchema: boolean;
+    captureWhitespaceSensitivity: 'strict' | 'ignore';
+    liquidDocParamDash: boolean;
+};
+export type LiquidPrinterArgs = {
+    leadingSpaceGroupId?: symbol[] | symbol;
+    trailingSpaceGroupId?: symbol[] | symbol;
+    isLiquidStatement?: boolean;
+    truncate?: boolean;
+};
+export type LiquidPrinter = (path: AstPath<LiquidHtmlNode>, args?: LiquidPrinterArgs) => Doc;
+export declare const nonTraversableProperties: Set<string>;
+export type Augmented<T, Aug> = {
+    [Property in keyof T]: [T[Property]] extends [(infer Item)[] | undefined] ? [Item] extends [AST.LiquidHtmlNode] ? Augmented<Item, Aug>[] : Item[] : T[Property] extends infer P ? P extends AST.LiquidHtmlNode ? Augmented<P, Aug> : P : never;
+} & Aug;
+export type AllAugmentations = WithParent & WithSiblings & WithFamily & WithCssProperties & WithWhitespaceHelpers;
+export type WithParent = {
+    parentNode?: ParentNode;
+};
+export type WithSiblings = {
+    prev: LiquidHtmlNode | undefined;
+    next: LiquidHtmlNode | undefined;
+};
+export type WithFamily = {
+    firstChild: LiquidHtmlNode | undefined;
+    lastChild: LiquidHtmlNode | undefined;
+};
+export type WithCssProperties = {
+    cssDisplay: string;
+    cssWhitespace: string;
+};
+export type WithWhitespaceHelpers = {
+    isDanglingWhitespaceSensitive: boolean;
+    isWhitespaceSensitive: boolean;
+    isLeadingWhitespaceSensitive: boolean;
+    isTrailingWhitespaceSensitive: boolean;
+    isIndentationSensitive: boolean;
+    hasLeadingWhitespace: boolean;
+    hasTrailingWhitespace: boolean;
+    hasDanglingWhitespace: boolean;
+};
+export type AugmentedNode<Aug> = Augmented<AST.LiquidHtmlNode, Aug>;
+export type Augment<Aug> = <NodeType extends AugmentedNode<Aug>>(options: LiquidParserOptions, node: NodeType, parentNode?: NodeType) => void;
+export type LiquidHtmlNode = Augmented<AST.LiquidHtmlNode, AllAugmentations>;
+export type DocumentNode = Augmented<AST.DocumentNode, AllAugmentations>;
+export type LiquidNode = Augmented<AST.LiquidNode, AllAugmentations>;
+export type LiquidStatement = Augmented<AST.LiquidStatement, AllAugmentations>;
+export type ParentNode = Augmented<AST.ParentNode, AllAugmentations>;
+export type LiquidRawTag = Augmented<AST.LiquidRawTag, AllAugmentations>;
+export type LiquidTag = Augmented<AST.LiquidTag, AllAugmentations>;
+export type LiquidTagNamed = Augmented<AST.LiquidTagNamed, AllAugmentations>;
+export type LiquidBranch = Augmented<AST.LiquidBranch, AllAugmentations>;
+export type LiquidBranchNamed = Augmented<AST.LiquidBranchNamed, AllAugmentations>;
+export type LiquidVariableOutput = Augmented<AST.LiquidVariableOutput, AllAugmentations>;
+export type HtmlNode = Augmented<AST.HtmlNode, AllAugmentations>;
+export type HtmlTag = Exclude<HtmlNode, HtmlComment>;
+export type HtmlElement = Augmented<AST.HtmlElement, AllAugmentations>;
+export type HtmlDanglingMarkerClose = Augmented<AST.HtmlDanglingMarkerClose, AllAugmentations>;
+export type HtmlVoidElement = Augmented<AST.HtmlVoidElement, AllAugmentations>;
+export type HtmlSelfClosingElement = Augmented<AST.HtmlSelfClosingElement, AllAugmentations>;
+export type HtmlRawNode = Augmented<AST.HtmlRawNode, AllAugmentations>;
+export type HtmlDoctype = Augmented<AST.HtmlDoctype, AllAugmentations>;
+export type HtmlComment = Augmented<AST.HtmlComment, AllAugmentations>;
+export type AttributeNode = Augmented<AST.AttributeNode, AllAugmentations>;
+export type AttrSingleQuoted = Augmented<AST.AttrSingleQuoted, AllAugmentations>;
+export type AttrDoubleQuoted = Augmented<AST.AttrDoubleQuoted, AllAugmentations>;
+export type AttrUnquoted = Augmented<AST.AttrUnquoted, AllAugmentations>;
+export type AttrEmpty = Augmented<AST.AttrEmpty, AllAugmentations>;
+export type LiquidExpression = Augmented<AST.LiquidExpression, AllAugmentations>;
+export type TextNode = Augmented<AST.TextNode, AllAugmentations>;
+export type RawMarkup = Augmented<AST.RawMarkup, AllAugmentations>;

package/dist/types.js

@@ -0,0 +1,53 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nonTraversableProperties = void 0;
+exports.isLiquidHtmlNode = isLiquidHtmlNode;
+const AST = __importStar(require("@platformos/liquid-html-parser"));
+function isLiquidHtmlNode(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        'type' in value &&
+        AST.NodeTypes.hasOwnProperty(value.type));
+}
+// Those properties create loops that would make walking infinite
+exports.nonTraversableProperties = new Set([
+    'parentNode',
+    'prev',
+    'next',
+    'firstChild',
+    'lastChild',
+]);
+//# sourceMappingURL=types.js.map

package/dist/utils.d.ts

@@ -0,0 +1,6 @@
+import { LiquidHtmlNode } from './types';
+export declare function assertNever(x: never): never;
+export declare function locStart(node: Pick<LiquidHtmlNode, 'position'> | string): number;
+export declare function locEnd(node: Pick<LiquidHtmlNode, 'position'> | string): number;
+export declare function deepGet<T = any>(path: (string | number)[], obj: any): T;
+export declare function dropLast<T>(n: number, xs: readonly T[]): T[];

package/dist/utils.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertNever = assertNever;
+exports.locStart = locStart;
+exports.locEnd = locEnd;
+exports.deepGet = deepGet;
+exports.dropLast = dropLast;
+function assertNever(x) {
+    throw new Error(`Unexpected object: ${x.type}`);
+}
+function locStart(node) {
+    if (typeof node === 'string')
+        return -1;
+    return node.position.start;
+}
+function locEnd(node) {
+    if (typeof node === 'string')
+        return -1;
+    return node.position.end;
+}
+function deepGet(path, obj) {
+    return path.reduce((curr, k) => {
+        if (curr && curr[k] !== undefined)
+            return curr[k];
+        return undefined;
+    }, obj);
+}
+function dropLast(n, xs) {
+    const result = [...xs];
+    for (let i = 0; i < n; i++) {
+        result.pop();
+    }
+    return result;
+}
+//# sourceMappingURL=utils.js.map

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@platformos/prettier-plugin-liquid",
+  "version": "0.0.2",
+  "description": "Prettier Liquid/HTML plugin for platformOS",
+  "author": "platformOS",
+  "homepage": "https://github.com/Platform-OS/platformos-tools/tree/main/packages/prettier-plugin-liquid#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Platform-OS/platformos-tools.git",
+    "directory": "packages/prettier-plugin-liquid"
+  },
+  "bugs": {
+    "url": "https://github.com/Platform-OS/platformos-tools/issues"
+  },
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public",
+    "@platformos:registry": "https://registry.npmjs.org"
+  },
+  "files": [
+    "grammar/*",
+    "dist/**/*.js",
+    "dist/**/*.ts",
+    "standalone.js",
+    "standalone.d.ts",
+    "standalone.js.LICENSE.txt",
+    "ThirdPartyNotices.txt"
+  ],
+  "scripts": {
+    "build": "yarn build:ts && yarn build:standalone",
+    "build:ci": "yarn build",
+    "build:standalone": "webpack -c webpack.config.js",
+    "build:ts": "tsc -p tsconfig.build.json",
+    "format": "prettier --write --ignore-unknown \"src/**/*.ts\"",
+    "format:check": "prettier --check --ignore-unknown \"src/**/*.ts\"",
+    "playground": "npx http-server playground",
+    "prerelease": "scripts/prerelease",
+    "prettier": "scripts/prettier",
+    "prettier2": "cross-env PRETTIER_MAJOR=2 scripts/prettier",
+    "prettier3": "cross-env PRETTIER_MAJOR=3 scripts/prettier",
+    "test": "vitest -c \"./vitest.config.mjs\"",
+    "test:3": "cross-env PRETTIER_MAJOR=3 yarn test",
+    "test:idempotence": "cross-env TEST_IDEMPOTENCE=true vitest run 'src/test/'",
+    "test:idempotence:3": "cross-env PRETTIER_MAJOR=3 yarn test:idempotence",
+    "type-check": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "prettier": "^2.0.0 || ^3.0.0"
+  },
+  "devDependencies": {
+    "@types/prettier": "^2.4.2",
+    "cross-env": "^7.0.3",
+    "module-alias": "^2.2.3",
+    "prettier2": "npm:prettier@^2.6.1",
+    "prettier3": "npm:prettier@^3.0.0",
+    "source-map-support": "^0.5.21",
+    "tsconfig-paths": "^3.14.1"
+  },
+  "dependencies": {
+    "@platformos/liquid-html-parser": "^0.0.2",
+    "html-styles": "^1.0.0"
+  }
+}