@wdprlib/parser 4.1.0 → 4.3.0

package/dist/index.cjs

@@ -31,7 +31,8 @@ var __export = (target, all) => {
 var exports_src = {};
 __export(exports_src, {
   tokenize: () => tokenize,
-  text: () => import_ast5.text,
+  text: () => import_ast6.text,
+  resolveTagCloud: () => resolveTagCloud,
   resolveModules: () => resolveModules,
   resolveListUsers: () => resolveListUsers,
   resolveIncludesWithTrace: () => resolveIncludesWithTrace,
@@ -45,36 +46,37 @@ __export(exports_src, {
   parseDateSelector: () => parseDateSelector,
   parseCategory: () => parseCategory,
   parse: () => parse,
-  paragraph: () => import_ast5.paragraph,
+  paragraph: () => import_ast6.paragraph,
   normalizeQuery: () => normalizeQuery,
-  listItemSubList: () => import_ast5.listItemSubList,
-  listItemElements: () => import_ast5.listItemElements,
-  list: () => import_ast5.list,
-  link: () => import_ast5.link,
-  lineBreak: () => import_ast5.lineBreak,
-  italics: () => import_ast5.italics,
+  listItemSubList: () => import_ast6.listItemSubList,
+  listItemElements: () => import_ast6.listItemElements,
+  list: () => import_ast6.list,
+  link: () => import_ast6.link,
+  lineBreak: () => import_ast6.lineBreak,
+  italics: () => import_ast6.italics,
+  isTagCloudModule: () => isTagCloudModule,
   isListUsersModule: () => isListUsersModule2,
-  horizontalRule: () => import_ast5.horizontalRule,
-  heading: () => import_ast5.heading,
+  horizontalRule: () => import_ast6.horizontalRule,
+  heading: () => import_ast6.heading,
   extractListUsersVariables: () => extractListUsersVariables,
   extractIncludeReferences: () => extractIncludeReferences,
   extractDataRequirements: () => extractDataRequirements,
   createToken: () => createToken,
-  createSettings: () => import_ast6.createSettings,
-  createPosition: () => import_ast5.createPosition,
-  createPoint: () => import_ast5.createPoint,
-  container: () => import_ast5.container,
+  createSettings: () => import_ast7.createSettings,
+  createPosition: () => import_ast6.createPosition,
+  createPoint: () => import_ast6.createPoint,
+  container: () => import_ast6.container,
   compileTemplate: () => compileTemplate,
   compileListUsersTemplate: () => compileListUsersTemplate,
-  bold: () => import_ast5.bold,
-  STYLE_SLOT_PREFIX: () => import_ast2.STYLE_SLOT_PREFIX,
+  bold: () => import_ast6.bold,
+  STYLE_SLOT_PREFIX: () => import_ast3.STYLE_SLOT_PREFIX,
   Parser: () => Parser,
   Lexer: () => Lexer,
-  DEFAULT_SETTINGS: () => import_ast6.DEFAULT_SETTINGS
+  DEFAULT_SETTINGS: () => import_ast7.DEFAULT_SETTINGS
 });
 module.exports = __toCommonJS(exports_src);
-var import_ast5 = require("@wdprlib/ast");
 var import_ast6 = require("@wdprlib/ast");
+var import_ast7 = require("@wdprlib/ast");
 
 // packages/parser/src/lexer/tokens.ts
 function createToken(type, value, position, lineStart = false) {
@@ -1441,7 +1443,7 @@ function parseNextBlock(ctx, skipWhitespace2, isAtEnd2) {
 }
 
 // packages/parser/src/parser/parse/context.ts
-var import_ast3 = require("@wdprlib/ast");
+var import_ast4 = require("@wdprlib/ast");
 
 // packages/parser/src/parser/rules/tokens.ts
 function currentToken(ctx) {
@@ -4527,6 +4529,92 @@ var listUsersModuleRule = {
   }
 };
 
+// packages/parser/src/parser/rules/block/module/tagcloud/parser.ts
+var import_ast = require("@wdprlib/ast");
+var FONT_SIZE_PATTERN = new RegExp(`^([0-9]+)(${import_ast.CSS_LENGTH_UNITS.join("|")})$`, "i");
+var COLOR_PATTERN = /^[0-9]+,[0-9]+,[0-9]+$/;
+var POSITIVE_INT_PATTERN = /^[0-9]+$/;
+var ERROR_FONT_FORMAT = "Unsupported format for font size. Use a number followed by a CSS length unit such as px, em or %.";
+var ERROR_FONT_MISMATCH = "Format for minFontSize and maxFontSize must use the same unit.";
+var ERROR_COLOR_FORMAT = 'Unsupported color format. Use "RRR,GGG,BBB" for Red,Green,Blue each within 0-255 range.';
+function errorBlock(message) {
+  return {
+    element: "container",
+    data: {
+      type: "div",
+      attributes: { class: "error-block" },
+      elements: [{ element: "text", data: message }]
+    }
+  };
+}
+function parseLimit(value) {
+  if (!value || !POSITIVE_INT_PATTERN.test(value))
+    return 50;
+  const num = Number.parseInt(value, 10);
+  return Number.isSafeInteger(num) && num > 0 ? num : 50;
+}
+function normalizeTarget(value) {
+  if (!value)
+    return "/system:page-tags/tag/";
+  let target = value;
+  if (!target.startsWith("/"))
+    target = `/${target}`;
+  if (!target.endsWith("/"))
+    target = `${target}/`;
+  return `${target}tag/`;
+}
+function parseColor(value) {
+  const [r = 0, g = 0, b = 0] = value.split(",").map((part) => Number.parseInt(part, 10));
+  return [r, g, b];
+}
+var tagCloudModuleRule = {
+  name: "module-tagcloud",
+  acceptsNames: ["tagcloud"],
+  hasBody: false,
+  parse(_ctx, _pos, args) {
+    const maxFontSize = args.maxfontsize;
+    const minFontSize = args.minfontsize;
+    const maxColor = args.maxcolor;
+    const minColor = args.mincolor;
+    let sizeSmall = 100;
+    let sizeBig = 300;
+    let fontSizeUnit = "%";
+    if (maxFontSize && minFontSize) {
+      const maxMatch = FONT_SIZE_PATTERN.exec(maxFontSize);
+      if (!maxMatch)
+        return errorBlock(ERROR_FONT_FORMAT);
+      const maxUnit = maxMatch[2].toLowerCase();
+      const minMatch = FONT_SIZE_PATTERN.exec(minFontSize);
+      if (!minMatch || minMatch[2].toLowerCase() !== maxUnit) {
+        return errorBlock(ERROR_FONT_MISMATCH);
+      }
+      sizeBig = Number.parseInt(maxMatch[1], 10);
+      sizeSmall = Number.parseInt(minMatch[1], 10);
+      fontSizeUnit = maxUnit;
+    }
+    let colorSmall = [128, 128, 192];
+    let colorBig = [64, 64, 128];
+    if (maxColor && minColor) {
+      if (!COLOR_PATTERN.test(maxColor) || !COLOR_PATTERN.test(minColor)) {
+        return errorBlock(ERROR_COLOR_FORMAT);
+      }
+      colorSmall = parseColor(minColor);
+      colorBig = parseColor(maxColor);
+    }
+    return {
+      module: "tag-cloud",
+      "min-font-size": sizeSmall,
+      "max-font-size": sizeBig,
+      "font-size-unit": fontSizeUnit,
+      "min-color": colorSmall,
+      "max-color": colorBig,
+      target: normalizeTarget(args.target),
+      limit: parseLimit(args.limit),
+      category: args.category || null
+    };
+  }
+};
+
 // packages/parser/src/parser/rules/block/module/mapping.ts
 var MODULE_RULES = [
   rateModuleRule,
@@ -4536,7 +4624,8 @@ var MODULE_RULES = [
   joinModuleRule,
   pageTreeModuleRule,
   listPagesModuleRule,
-  listUsersModuleRule
+  listUsersModuleRule,
+  tagCloudModuleRule
 ];
 var moduleRuleMap = new Map;
 for (const rule of MODULE_RULES) {
@@ -5617,18 +5706,130 @@ function extractListUsersModule(listUsers, state, result) {
   result.compiledListUsersTemplates.set(id, compileListUsersTemplate(body));
 }
 
+// packages/parser/src/parser/rules/block/module/tagcloud/resolve.ts
+function isTagCloudModule(module2) {
+  return module2.module === "tag-cloud";
+}
+var NO_TAGS_MESSAGE_PREFIX = "It seems you have no tags attached to pages. To attach a tag simply click on the ";
+var NO_TAGS_MESSAGE_SUFFIX = " button at the bottom of any page.";
+function rawUrlEncode(value) {
+  return encodeURIComponent(value).replace(/[!'()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+function selectTags(tags, limit) {
+  return tags.toSorted((a, b) => b.weight - a.weight || compareTags(a.tag, b.tag)).slice(0, limit).toSorted((a, b) => compareTags(a.tag, b.tag));
+}
+function compareTags(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function resolveTagCloud(module2, data) {
+  if (data.status === "category-not-found") {
+    return [
+      {
+        element: "container",
+        data: {
+          type: "div",
+          attributes: { class: "error-block" },
+          elements: [{ element: "text", data: `Category "${data.category}" can not be found.` }]
+        }
+      }
+    ];
+  }
+  const tags = selectTags(data.tags, module2.limit);
+  if (tags.length === 0) {
+    return [noTagsMessage()];
+  }
+  let minWeight = Number.POSITIVE_INFINITY;
+  let maxWeight = Number.NEGATIVE_INFINITY;
+  for (const tag of tags) {
+    if (tag.weight < minWeight)
+      minWeight = tag.weight;
+    if (tag.weight > maxWeight)
+      maxWeight = tag.weight;
+  }
+  const weightRange = maxWeight - minWeight;
+  const categorySuffix = data.category !== null ? `/category/${rawUrlEncode(data.category)}` : "";
+  const anchors = [];
+  for (const tag of tags) {
+    const a = weightRange === 0 ? 0 : (tag.weight - minWeight) / weightRange;
+    const fontSize = interpolate(module2["min-font-size"], module2["max-font-size"], a);
+    const [r, g, b] = [0, 1, 2].map((i) => interpolate(module2["min-color"][i], module2["max-color"][i], a));
+    anchors.push({ element: "text", data: `
+` });
+    anchors.push({
+      element: "anchor",
+      data: {
+        target: null,
+        attributes: {
+          class: "tag",
+          href: `${module2.target}${rawUrlEncode(tag.tag)}${categorySuffix}`,
+          style: `font-size: ${fontSize}${module2["font-size-unit"]}; color: rgb(${r}, ${g}, ${b});`
+        },
+        elements: [{ element: "text", data: tag.tag }]
+      }
+    });
+  }
+  anchors.push({ element: "text", data: `
+` });
+  return [
+    {
+      element: "container",
+      data: {
+        type: "div",
+        attributes: { class: "pages-tag-cloud-box" },
+        elements: anchors
+      }
+    }
+  ];
+}
+function interpolate(min, max, a) {
+  return Math.round(min + (max - min) * a);
+}
+function noTagsMessage() {
+  return {
+    element: "container",
+    data: {
+      type: "paragraph",
+      attributes: {},
+      elements: [
+        { element: "text", data: NO_TAGS_MESSAGE_PREFIX },
+        {
+          element: "container",
+          data: {
+            type: "italics",
+            attributes: {},
+            elements: [{ element: "text", data: "tags" }]
+          }
+        },
+        { element: "text", data: NO_TAGS_MESSAGE_SUFFIX }
+      ]
+    }
+  };
+}
+
+// packages/parser/src/parser/rules/block/module/listpages/extraction/tagcloud.ts
+function extractTagCloudModule(tagCloud, state, result) {
+  const id = state.nextId++;
+  result.requirements.tagCloud.push({
+    id,
+    category: tagCloud.category,
+    limit: tagCloud.limit
+  });
+}
+
 // packages/parser/src/parser/rules/block/module/listpages/extract.ts
 function extractDataRequirements(ast) {
   const result = {
     requirements: {
       listPages: [],
-      listUsers: []
+      listUsers: [],
+      tagCloud: []
     },
     compiledListPagesTemplates: new Map,
     compiledListUsersTemplates: new Map
   };
   const listPagesState = { nextId: 0 };
   const listUsersState = { nextId: 0 };
+  const tagCloudState = { nextId: 0 };
   walkElements(ast.elements, (element) => {
     if (element.element !== "module")
       return;
@@ -5636,6 +5837,8 @@ function extractDataRequirements(ast) {
       extractListPagesModule(element.data, listPagesState, result);
     } else if (isListUsersModule(element.data)) {
       extractListUsersModule(element.data, listUsersState, result);
+    } else if (isTagCloudModule(element.data)) {
+      extractTagCloudModule(element.data, tagCloudState, result);
     }
   });
   return result;
@@ -6751,6 +6954,16 @@ async function buildListUsersDataMap(dataProvider, requirements) {
   }
   return dataMap;
 }
+async function buildTagCloudDataMap(dataProvider, requirements) {
+  const dataMap = new Map;
+  for (const req of requirements) {
+    const data = await dataProvider.fetchTagCloud?.(req);
+    if (data) {
+      dataMap.set(req.id, data);
+    }
+  }
+  return dataMap;
+}
 
 // packages/parser/src/parser/rules/block/module/resolution/contexts.ts
 async function buildListPagesContext(dataProvider, requirements, compiledTemplates, parse, urlPath) {
@@ -6767,6 +6980,16 @@ async function buildListPagesContext(dataProvider, requirements, compiledTemplat
     parse
   };
 }
+async function buildTagCloudContext(dataProvider, requirements) {
+  if (requirements.length === 0 || !dataProvider.fetchTagCloud) {
+    return null;
+  }
+  const dataMap = await buildTagCloudDataMap(dataProvider, requirements);
+  if (dataMap.size === 0) {
+    return null;
+  }
+  return { dataMap };
+}
 async function buildListUsersContext(dataProvider, requirements, compiledTemplates, parse) {
   if (requirements.length === 0 || !dataProvider.fetchListUsers) {
     return null;
@@ -6823,10 +7046,27 @@ function resolveDynamicModuleElement(element, ctx, ids) {
       ids: { ...ids, listUsersId: listUsersId + 1 }
     };
   }
+  if (isTagCloudModule(element.data)) {
+    const elements = [];
+    const tagCloudId = ids.tagCloudId;
+    if (ctx.tagCloud) {
+      const moduleData = ctx.tagCloud.dataMap.get(tagCloudId);
+      if (moduleData) {
+        elements.push(...resolveTagCloud(element.data, moduleData));
+      }
+    } else if (!ctx.fetchTagCloudProvided) {
+      elements.push(element);
+    }
+    return {
+      handled: true,
+      elements,
+      ids: { ...ids, tagCloudId: tagCloudId + 1 }
+    };
+  }
   return { handled: false, elements: [element], ids };
 }
 function countDynamicModules(elements) {
-  const counts = { listPagesId: 0, listUsersId: 0 };
+  const counts = { listPagesId: 0, listUsersId: 0, tagCloudId: 0 };
   walkElements(elements, (element) => {
     if (element.element !== "module")
       return;
@@ -6834,6 +7074,8 @@ function countDynamicModules(elements) {
       counts.listPagesId++;
     } else if (isListUsersModule2(element.data)) {
       counts.listUsersId++;
+    } else if (isTagCloudModule(element.data)) {
+      counts.tagCloudId++;
     }
   });
   return counts;
@@ -6844,12 +7086,18 @@ function walkAndResolve(elements, ctx) {
   const result = [];
   let listPagesId = ctx.listPagesIdCounter;
   let listUsersId = ctx.listUsersIdCounter;
+  let tagCloudId = ctx.tagCloudIdCounter;
   for (const element of elements) {
-    const dynamicModule = resolveDynamicModuleElement(element, ctx, { listPagesId, listUsersId });
+    const dynamicModule = resolveDynamicModuleElement(element, ctx, {
+      listPagesId,
+      listUsersId,
+      tagCloudId
+    });
     if (dynamicModule.handled) {
       result.push(...dynamicModule.elements);
       listPagesId = dynamicModule.ids.listPagesId;
       listUsersId = dynamicModule.ids.listUsersId;
+      tagCloudId = dynamicModule.ids.tagCloudId;
       continue;
     }
     if (isIfTagsElement(element)) {
@@ -6860,21 +7108,25 @@ function walkAndResolve(elements, ctx) {
           const childResult = walkAndResolve(ifTagsData.elements, {
             ...ctx,
             listPagesIdCounter: listPagesId,
-            listUsersIdCounter: listUsersId
+            listUsersIdCounter: listUsersId,
+            tagCloudIdCounter: tagCloudId
           });
           result.push(...childResult.elements);
           listPagesId = childResult.nextListPagesId;
           listUsersId = childResult.nextListUsersId;
+          tagCloudId = childResult.nextTagCloudId;
         } else {
           const counts = countDynamicModules(ifTagsData.elements);
           listPagesId += counts.listPagesId;
           listUsersId += counts.listUsersId;
+          tagCloudId += counts.tagCloudId;
         }
       } else {
         const childResult = walkAndResolve(ifTagsData.elements, {
           ...ctx,
           listPagesIdCounter: listPagesId,
-          listUsersIdCounter: listUsersId
+          listUsersIdCounter: listUsersId,
+          tagCloudIdCounter: tagCloudId
         });
         result.push({
           element: "if-tags",
@@ -6885,32 +7137,41 @@ function walkAndResolve(elements, ctx) {
         });
         listPagesId = childResult.nextListPagesId;
         listUsersId = childResult.nextListUsersId;
+        tagCloudId = childResult.nextTagCloudId;
       }
       continue;
     }
-    const mapped = mapElementChildrenWithState(element, { listPagesId, listUsersId }, (children, state) => {
+    const mapped = mapElementChildrenWithState(element, { listPagesId, listUsersId, tagCloudId }, (children, state) => {
       const childResult = walkAndResolve(children, {
         ...ctx,
         listPagesIdCounter: state.listPagesId,
-        listUsersIdCounter: state.listUsersId
+        listUsersIdCounter: state.listUsersId,
+        tagCloudIdCounter: state.tagCloudId
       });
       return {
         elements: childResult.elements,
         state: {
           listPagesId: childResult.nextListPagesId,
-          listUsersId: childResult.nextListUsersId
+          listUsersId: childResult.nextListUsersId,
+          tagCloudId: childResult.nextTagCloudId
         }
       };
     });
     result.push(mapped.element);
     listPagesId = mapped.state.listPagesId;
     listUsersId = mapped.state.listUsersId;
+    tagCloudId = mapped.state.tagCloudId;
   }
-  return { elements: result, nextListPagesId: listPagesId, nextListUsersId: listUsersId };
+  return {
+    elements: result,
+    nextListPagesId: listPagesId,
+    nextListUsersId: listUsersId,
+    nextTagCloudId: tagCloudId
+  };
 }
 
 // packages/parser/src/parser/rules/block/module/resolution/styles.ts
-var import_ast = require("@wdprlib/ast");
+var import_ast2 = require("@wdprlib/ast");
 function collectStyles(elements) {
   const styles = [];
   const ctx = { nextSlotId: 0 };
@@ -6926,7 +7187,7 @@ function collectStylesFromElements(elements, styles, ctx) {
     }
     if (element.element === "if-tags") {
       const slotId = ctx.nextSlotId++;
-      styles.push(`${import_ast.STYLE_SLOT_PREFIX}${slotId}`);
+      styles.push(`${import_ast2.STYLE_SLOT_PREFIX}${slotId}`);
       const data = { ...element.data, _styleSlot: slotId };
       result.push({
         element: "if-tags",
@@ -6945,15 +7206,19 @@ async function resolveModules(ast, dataProvider, options) {
   const parse = createModuleParseFunction(options, dataProvider);
   const listPagesCtx = await buildListPagesContext(dataProvider, options.requirements.listPages ?? [], options.compiledListPagesTemplates, parse, options.urlPath);
   const listUsersCtx = await buildListUsersContext(dataProvider, options.requirements.listUsers ?? [], options.compiledListUsersTemplates, parse);
+  const tagCloudCtx = await buildTagCloudContext(dataProvider, options.requirements.tagCloud ?? []);
   const pageTags = dataProvider.getPageTags?.() ?? null;
   const resolvedElements = walkAndResolve(ast.elements, {
     listPages: listPagesCtx,
     listUsers: listUsersCtx,
+    tagCloud: tagCloudCtx,
     fetchListPagesProvided: dataProvider.fetchListPages !== undefined,
     fetchListUsersProvided: dataProvider.fetchListUsers !== undefined,
+    fetchTagCloudProvided: dataProvider.fetchTagCloud !== undefined,
     pageTags,
     listPagesIdCounter: 0,
-    listUsersIdCounter: 0
+    listUsersIdCounter: 0,
+    tagCloudIdCounter: 0
   });
   const { elements: finalElements, styles } = collectStyles(resolvedElements.elements);
   const result = {
@@ -6985,7 +7250,7 @@ function createModuleSourceTransform(options, dataProvider) {
 }
 
 // packages/parser/src/parser/rules/block/module/index.ts
-var import_ast2 = require("@wdprlib/ast");
+var import_ast3 = require("@wdprlib/ast");
 
 // packages/parser/src/parser/rules/block/footnoteblock/attributes.ts
 function parseFootnoteBlockAttributes(ctx, startPos) {
@@ -9053,6 +9318,177 @@ var bibliographyRule = {
   }
 };
 
+// packages/parser/src/parser/rules/block/gallery/items.ts
+function parseGalleryItemLine(content) {
+  const spacePos = content.indexOf(" ");
+  let source = spacePos < 0 ? content : content.slice(0, spacePos);
+  const attrText = spacePos < 0 ? "" : content.slice(spacePos + 1);
+  let newWindow = false;
+  if (source.startsWith("*")) {
+    source = source.slice(1);
+    newWindow = true;
+  }
+  const attrs = parseItemAttrs(attrText);
+  let link = attrs.get("link") ?? null;
+  if (link !== null && link.startsWith("*")) {
+    newWindow = true;
+    link = link.slice(1);
+  }
+  const alt = attrs.get("alt") ?? null;
+  return { source, link, alt, newWindow };
+}
+function parseItemAttrs(text) {
+  const attrs = new Map;
+  const parts = text.trim().split('="');
+  let key = parts[0]?.trim() ?? "";
+  for (let i = 1;i < parts.length; i++) {
+    const val = parts[i] ?? "";
+    const quotePos = val.lastIndexOf('"');
+    if (quotePos < 0) {
+      attrs.set(key, "");
+      key = val.slice(1).trim();
+    } else {
+      attrs.set(key, stripslashes(val.slice(0, quotePos)));
+      key = val.slice(quotePos + 1).trim();
+    }
+  }
+  return attrs;
+}
+function stripslashes(value) {
+  return value.replace(/\\(.)/gs, "$1").replace(/\\$/, "");
+}
+
+// packages/parser/src/parser/rules/block/gallery/index.ts
+var GALLERY_SIZES = ["small", "medium", "thumbnail", "square", "original"];
+function normalizeSize(value) {
+  return value !== undefined && GALLERY_SIZES.includes(value) ? value : "thumbnail";
+}
+function normalizeViewer(value) {
+  return value !== "no" && value !== "false";
+}
+function normalizeOrder(value) {
+  switch (value) {
+    case "name":
+    case "name desc":
+    case "created_at":
+    case "created_at desc":
+      return value;
+    case "nameDesc":
+      return "name desc";
+    case "dateAdded":
+      return "created_at";
+    case "dateAddedDesc":
+      return "created_at desc";
+    case "name desc desc":
+      return "name";
+    case "created_at desc desc":
+      return "created_at";
+    default:
+      return "name";
+  }
+}
+function tryParseGalleryContent(ctx, pos) {
+  const start = pos;
+  if (ctx.tokens[pos]?.type !== "NEWLINE") {
+    return null;
+  }
+  const lines = [];
+  let p = pos + 1;
+  for (;; ) {
+    const colon = ctx.tokens[p];
+    if (colon?.type !== "COLON" || !colon.lineStart) {
+      break;
+    }
+    const space = ctx.tokens[p + 1];
+    if (space?.type !== "WHITESPACE" || !space.value.startsWith(" ")) {
+      break;
+    }
+    let content = "";
+    let q = p + 1;
+    while (q < ctx.tokens.length) {
+      const token5 = ctx.tokens[q];
+      if (!token5 || token5.type === "NEWLINE" || token5.type === "EOF") {
+        break;
+      }
+      content += token5.value;
+      q++;
+    }
+    if (content === " ") {
+      return null;
+    }
+    if (ctx.tokens[q]?.type !== "NEWLINE") {
+      return null;
+    }
+    lines.push(content.trim());
+    p = q + 1;
+  }
+  if (lines.length === 0) {
+    return null;
+  }
+  if (ctx.tokens[p]?.type !== "BLOCK_END_OPEN") {
+    return null;
+  }
+  const nameResult = parseBlockName(ctx, p + 1);
+  if (!nameResult || nameResult.name !== "gallery") {
+    return null;
+  }
+  const closePos = p + 1 + nameResult.consumed;
+  if (ctx.tokens[closePos]?.type !== "BLOCK_CLOSE") {
+    return null;
+  }
+  return { lines, consumed: closePos + 1 - start };
+}
+var galleryRule = {
+  name: "gallery",
+  startTokens: ["BLOCK_OPEN"],
+  requiresLineStart: true,
+  parse(ctx) {
+    if (ctx.tokens[ctx.pos]?.type !== "BLOCK_OPEN") {
+      return { success: false };
+    }
+    let pos = ctx.pos + 1;
+    const nameResult = parseBlockName(ctx, pos);
+    if (!nameResult || nameResult.name !== "gallery") {
+      return { success: false };
+    }
+    pos += nameResult.consumed;
+    const attrResult = parseAttributesRaw(ctx, pos);
+    pos += attrResult.consumed;
+    if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
+      return { success: false };
+    }
+    pos++;
+    const size = normalizeSize(attrResult.attrs.size);
+    const viewer = normalizeViewer(attrResult.attrs.viewer);
+    const order = normalizeOrder(attrResult.attrs.order);
+    const openConsumed = pos - ctx.pos;
+    const content = tryParseGalleryContent(ctx, pos);
+    if (!content) {
+      return {
+        success: true,
+        elements: [
+          {
+            element: "gallery",
+            data: { size, order, viewer, content: { type: "auto", files: null } }
+          }
+        ],
+        consumed: openConsumed
+      };
+    }
+    const items = content.lines.map(parseGalleryItemLine);
+    return {
+      success: true,
+      elements: [
+        {
+          element: "gallery",
+          data: { size, order, viewer, content: { type: "items", items } }
+        }
+      ],
+      consumed: openConsumed + content.consumed
+    };
+  }
+};
+
 // packages/parser/src/parser/rules/block/index.ts
 var blockRules = [
   blockCommentRule,
@@ -9082,6 +9518,7 @@ var blockRules = [
   iframeRule,
   iftagsRule,
   bibliographyRule,
+  galleryRule,
   divRule
 ];
 // packages/parser/src/parser/rules/inline/formatting/container.ts
@@ -11932,7 +12369,7 @@ function createParseContext(tokens, options = {}) {
     pos: 0,
     version: options.version ?? "wikidot",
     trackPositions: options.trackPositions ?? true,
-    settings: options.settings ?? import_ast3.DEFAULT_SETTINGS,
+    settings: options.settings ?? import_ast4.DEFAULT_SETTINGS,
     footnotes: [],
     tocEntries: [],
     codeBlocks: [],
@@ -12897,12 +13334,12 @@ function preprocess(text) {
 }
 
 // packages/parser/src/parser/preprocess/expr/evaluate.ts
-var import_ast4 = require("@wdprlib/ast");
+var import_ast5 = require("@wdprlib/ast");
 function evaluateDirective(kind, match) {
   if (kind === "expr") {
-    const result2 = import_ast4.evaluateExpression(match.head);
+    const result2 = import_ast5.evaluateExpression(match.head);
     if (result2.success)
-      return import_ast4.formatExprValue(result2.value);
+      return import_ast5.formatExprValue(result2.value);
     if (result2.error === "empty expression")
       return "";
     return "ERROR";
@@ -12910,11 +13347,11 @@ function evaluateDirective(kind, match) {
   if (kind === "if") {
     if (!match.hasPipe)
       return "";
-    return import_ast4.isTruthy(match.head) ? match.thenText : match.elseText;
+    return import_ast5.isTruthy(match.head) ? match.thenText : match.elseText;
   }
   if (!match.hasPipe)
     return "";
-  const result = import_ast4.evaluateExpression(match.head);
+  const result = import_ast5.evaluateExpression(match.head);
   if (!result.success)
     return "ERROR";
   return result.value !== 0 && !Number.isNaN(result.value) ? match.thenText : match.elseText;