@wdprlib/parser 4.1.0 → 4.3.0

package/src/parser/rules/block/gallery/index.ts

@@ -0,0 +1,215 @@
+/**
+ *
+ * Block rule for the Wikidot `[[gallery]]` image gallery.
+ *
+ * ```
+ * [[gallery size="thumbnail" order="name" viewer="no"]]
+ * : first-image.jpg
+ * : *page/other-image.jpg link="some-page" alt="Alt text"
+ * [[/gallery]]
+ * ```
+ *
+ * The content form requires the `]]` to be followed immediately by one or
+ * more `: source` lines and a `[[/gallery]]` close tag (Wikidot regex
+ * `\[\[gallery(\s[^\]]*?)?\]\](?:((?:\n: [^\n]+)+)\n\[\[\/gallery\]\])?`).
+ * Anything else falls back to the standalone content-less form, which shows
+ * the current page's image attachments after data resolution
+ * (`content: { type: "auto", files: null }`); the following text then
+ * parses normally.
+ *
+ * Honored opening-tag attributes are `size` (small / medium / thumbnail /
+ * square / original, fallback thumbnail), `viewer` (`"no"`/`"false"`
+ * disable the lightbox) and `order` (auto-collection sort order, with
+ * Wikidot's deprecated aliases normalized).
+ *
+ * Deliberate differences from the Wikidot parser: the opening tag must
+ * fit on one line and attribute names are lowercased with unquoted values
+ * accepted (both shared with wdpr's other block rules), and `flickr:`
+ * sources get no special treatment — they resolve like any other
+ * filename (wdpr does not call the Flickr API).
+ *
+ * @module
+ */
+import type { Element, GalleryItem, GalleryOrder, GallerySize } from "@wdprlib/ast";
+import type { BlockRule, ParseContext, RuleResult } from "../../types";
+import { parseAttributesRaw, parseBlockName } from "../utils";
+import { parseGalleryItemLine } from "./items";
+
+export { parseGalleryItemLine } from "./items";
+
+const GALLERY_SIZES: readonly string[] = ["small", "medium", "thumbnail", "square", "original"];
+
+/** Validate a size keyword, falling back to thumbnail like Wikidot. */
+function normalizeSize(value: string | undefined): GallerySize {
+  return value !== undefined && GALLERY_SIZES.includes(value)
+    ? (value as GallerySize)
+    : "thumbnail";
+}
+
+/** `viewer="no"` / `viewer="false"` disable the lightbox; anything else enables it. */
+function normalizeViewer(value: string | undefined): boolean {
+  return value !== "no" && value !== "false";
+}
+
+/**
+ * Normalize the `order` attribute, folding Wikidot's deprecated aliases
+ * (`nameDesc`, `dateAdded`, `dateAddedDesc`) and the documented
+ * ListPages-compatibility forms (`"name desc desc"` / `"created_at desc
+ * desc"`, which mean the same as without the `desc desc`).
+ */
+function normalizeOrder(value: string | undefined): GalleryOrder {
+  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";
+  }
+}
+
+interface GalleryContentResult {
+  /** Trimmed line contents (after the leading `: `) */
+  lines: string[];
+  /** Token count from the content start (the NEWLINE after `]]`) through `[[/gallery]]` */
+  consumed: number;
+}
+
+/**
+ * Try to match the content form starting at `pos` (the token right after the
+ * opening tag's `]]`): one NEWLINE, then consecutive `: source` lines, then a
+ * NEWLINE directly followed by `[[/gallery]]`. Returns null when the token
+ * stream deviates from the Wikidot regex, which makes the gallery standalone.
+ */
+function tryParseGalleryContent(ctx: ParseContext, pos: number): GalleryContentResult | null {
+  const start = pos;
+  if (ctx.tokens[pos]?.type !== "NEWLINE") {
+    return null;
+  }
+
+  const lines: string[] = [];
+  let p = pos + 1;
+
+  for (;;) {
+    const colon = ctx.tokens[p];
+    if (colon?.type !== "COLON" || !colon.lineStart) {
+      break;
+    }
+    // Wikidot requires a literal space after the colon (`\n: `)
+    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 token = ctx.tokens[q];
+      if (!token || token.type === "NEWLINE" || token.type === "EOF") {
+        break;
+      }
+      content += token.value;
+      q++;
+    }
+    // `: [^\n]+` needs at least one character after the space
+    if (content === " ") {
+      return null;
+    }
+    if (ctx.tokens[q]?.type !== "NEWLINE") {
+      // line hit EOF: the close tag can no longer follow on its own line
+      return null;
+    }
+
+    lines.push(content.trim());
+    p = q + 1;
+  }
+
+  if (lines.length === 0) {
+    return null;
+  }
+
+  // The last consumed NEWLINE must be directly followed by [[/gallery]]
+  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 };
+}
+
+export const galleryRule: BlockRule = {
+  name: "gallery",
+  startTokens: ["BLOCK_OPEN"],
+  requiresLineStart: true,
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    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: GalleryItem[] = content.lines.map(parseGalleryItemLine);
+
+    return {
+      success: true,
+      elements: [
+        {
+          element: "gallery",
+          data: { size, order, viewer, content: { type: "items", items } },
+        },
+      ],
+      consumed: openConsumed + content.consumed,
+    };
+  },
+};

package/src/parser/rules/block/gallery/items.ts

@@ -0,0 +1,62 @@
+import type { GalleryItem } from "@wdprlib/ast";
+
+/**
+ * Parse one gallery content line (the text after the leading `: `,
+ * already trimmed) into a {@link GalleryItem}.
+ *
+ * The text before the first space is the source; the rest is parsed as
+ * `key="value"` attributes of which `link` and `alt` are honored. A
+ * leading `*` on the source or on the link value requests a new window.
+ */
+export function parseGalleryItemLine(content: string): GalleryItem {
+  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 };
+}
+
+/**
+ * Parse `key="value"` attribute pairs from a gallery item line, following
+ * the splitting behavior of Wikidot's gallery `getAttrs()`: fragments are
+ * separated by `="`, values run to the last `"` in each fragment and are
+ * backslash-unescaped, and keys are not lowercased.
+ */
+function parseItemAttrs(text: string): Map<string, string> {
+  const attrs = new Map<string, string>();
+  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;
+}
+
+/** PHP-style `stripslashes()`: drop each escaping backslash, and a trailing lone one. */
+function stripslashes(value: string): string {
+  return value.replace(/\\(.)/gs, "$1").replace(/\\$/, "");
+}

package/src/parser/rules/block/index.ts

@@ -49,6 +49,7 @@ import { iftagsRule } from "./iftags";
 import { tocRule } from "./toc";
 import { orphanLiRule } from "./orphan-li";
 import { bibliographyRule } from "./bibliography";
+import { galleryRule } from "./gallery";
 
 export { headingRule } from "./heading";
 export { horizontalRuleRule } from "./horizontal-rule";
@@ -79,6 +80,7 @@ export { iftagsRule } from "./iftags";
 export { tocRule } from "./toc";
 export { orphanLiRule } from "./orphan-li";
 export { bibliographyRule } from "./bibliography";
+export { galleryRule } from "./gallery";
 
 /**
  * All block rules in priority order.
@@ -120,6 +122,7 @@ export const blockRules: BlockRule[] = [
   iframeRule,
   iftagsRule,
   bibliographyRule,
+  galleryRule,
   divRule,
   // paragraphRule is not included - used as fallback
 ];

package/src/parser/rules/block/module/index.ts

@@ -128,6 +128,16 @@ export {
   resolveListUsers,
 } from "./listusers";
 
+// TagCloud module
+export type {
+  TagCloudDataRequirement,
+  TagCloudTagData,
+  TagCloudExternalData,
+  TagCloudDataFetcher,
+  TagCloudModuleData,
+} from "./tagcloud";
+export { tagCloudModuleRule as tagCloudRule, isTagCloudModule, resolveTagCloud } from "./tagcloud";
+
 // Module resolver
 export type { ModuleSourceTransform, ResolveOptions } from "./resolve";
 export { resolveModules } from "./resolve";

package/src/parser/rules/block/module/listpages/extract.ts

@@ -32,6 +32,11 @@ import {
   isListUsersModule,
   type ListUsersExtractionState,
 } from "./extraction/listusers";
+import {
+  extractTagCloudModule,
+  isTagCloudModule,
+  type TagCloudExtractionState,
+} from "./extraction/tagcloud";
 import type { ExtractionResult } from "./extraction/result";
 export type { ExtractionResult } from "./extraction/result";
 
@@ -54,6 +59,7 @@ export function extractDataRequirements(ast: SyntaxTree): ExtractionResult {
     requirements: {
       listPages: [],
       listUsers: [],
+      tagCloud: [],
     },
     compiledListPagesTemplates: new Map(),
     compiledListUsersTemplates: new Map(),
@@ -61,6 +67,7 @@ export function extractDataRequirements(ast: SyntaxTree): ExtractionResult {
 
   const listPagesState: ListPagesExtractionState = { nextId: 0 };
   const listUsersState: ListUsersExtractionState = { nextId: 0 };
+  const tagCloudState: TagCloudExtractionState = { nextId: 0 };
 
   walkElements(ast.elements, (element) => {
     if (element.element !== "module") return;
@@ -69,6 +76,8 @@ export function extractDataRequirements(ast: SyntaxTree): ExtractionResult {
       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);
     }
   });
 

package/src/parser/rules/block/module/listpages/extraction/tagcloud.ts

@@ -0,0 +1,25 @@
+import type { Module } from "@wdprlib/ast";
+import { isTagCloudModule } from "../../tagcloud/resolve";
+import type { ExtractionResult } from "./result";
+
+export type TagCloudModuleForExtraction = Extract<Module, { module: "tag-cloud" }>;
+
+export interface TagCloudExtractionState {
+  nextId: number;
+}
+
+export { isTagCloudModule };
+
+export function extractTagCloudModule(
+  tagCloud: TagCloudModuleForExtraction,
+  state: TagCloudExtractionState,
+  result: ExtractionResult,
+): void {
+  const id = state.nextId++;
+
+  result.requirements.tagCloud.push({
+    id,
+    category: tagCloud.category,
+    limit: tagCloud.limit,
+  });
+}

package/src/parser/rules/block/module/listpages/types/data-requirements.ts

@@ -1,4 +1,5 @@
 import type { ListUsersDataRequirement } from "../../listusers/types";
+import type { TagCloudDataRequirement } from "../../tagcloud/types";
 import type { ListPagesQuery } from "./query";
 import type { ListPagesVariable } from "./variables";
 
@@ -49,4 +50,5 @@ export interface ListPagesDataRequirement {
 export interface DataRequirements {
   listPages: ListPagesDataRequirement[];
   listUsers: ListUsersDataRequirement[];
+  tagCloud: TagCloudDataRequirement[];
 }

package/src/parser/rules/block/module/mapping.ts

@@ -19,6 +19,7 @@ import { joinModuleRule } from "./join/index";
 import { pageTreeModuleRule } from "./page-tree/index";
 import { listPagesModuleRule } from "./listpages/parser";
 import { listUsersModuleRule } from "./listusers/parser";
+import { tagCloudModuleRule } from "./tagcloud/parser";
 
 /**
  * Complete list of all registered module rules.
@@ -35,6 +36,7 @@ export const MODULE_RULES: ModuleRule[] = [
   pageTreeModuleRule,
   listPagesModuleRule,
   listUsersModuleRule,
+  tagCloudModuleRule,
 ];
 
 /**

package/src/parser/rules/block/module/resolution/contexts.ts

@@ -9,8 +9,9 @@ import type {
   ListUsersDataRequirement,
   ListUsersExternalData,
 } from "../listusers/types";
+import type { TagCloudDataRequirement, TagCloudExternalData } from "../tagcloud/types";
 import type { ParseFunction } from "../listpages/resolve";
-import { buildListPagesDataMap, buildListUsersDataMap } from "./data-maps";
+import { buildListPagesDataMap, buildListUsersDataMap, buildTagCloudDataMap } from "./data-maps";
 
 /**
  * Context for ListPages resolution.
@@ -54,6 +55,33 @@ export async function buildListPagesContext(
   };
 }
 
+/**
+ * Context for TagCloud resolution.
+ *
+ * TagCloud has no template body, so unlike ListPages/ListUsers the context
+ * carries only the fetched data.
+ */
+export interface TagCloudContext {
+  dataMap: Map<number, TagCloudExternalData>;
+}
+
+export async function buildTagCloudContext(
+  dataProvider: DataProvider,
+  requirements: TagCloudDataRequirement[],
+): Promise<TagCloudContext | null> {
+  if (requirements.length === 0 || !dataProvider.fetchTagCloud) {
+    return null;
+  }
+
+  const dataMap = await buildTagCloudDataMap(dataProvider, requirements);
+
+  if (dataMap.size === 0) {
+    return null;
+  }
+
+  return { dataMap };
+}
+
 export async function buildListUsersContext(
   dataProvider: DataProvider,
   requirements: ListUsersDataRequirement[],

package/src/parser/rules/block/module/resolution/data-maps.ts

@@ -1,6 +1,7 @@
 import type { DataProvider } from "../types-common";
 import type { ListPagesDataRequirement, ListPagesExternalData } from "../listpages/types";
 import type { ListUsersDataRequirement, ListUsersExternalData } from "../listusers/types";
+import type { TagCloudDataRequirement, TagCloudExternalData } from "../tagcloud/types";
 import { parseUrlParams, resolveAndNormalizeQuery } from "../listpages/url-resolver";
 
 export async function buildListPagesDataMap(
@@ -37,3 +38,19 @@ export async function buildListUsersDataMap(
 
   return dataMap;
 }
+
+export async function buildTagCloudDataMap(
+  dataProvider: DataProvider,
+  requirements: TagCloudDataRequirement[],
+): Promise<Map<number, TagCloudExternalData>> {
+  const dataMap = new Map<number, TagCloudExternalData>();
+
+  for (const req of requirements) {
+    const data = await dataProvider.fetchTagCloud?.(req);
+    if (data) {
+      dataMap.set(req.id, data);
+    }
+  }
+
+  return dataMap;
+}

package/src/parser/rules/block/module/resolution/dynamic-modules.ts

@@ -1,19 +1,23 @@
 import type { Element } from "@wdprlib/ast";
 import { isListPagesModule, resolveListPages } from "../listpages/resolve";
 import { isListUsersModule, resolveListUsers } from "../listusers/resolve";
+import { isTagCloudModule, resolveTagCloud } from "../tagcloud/resolve";
 import { walkElements } from "../walk";
-import type { ListPagesContext, ListUsersContext } from "./contexts";
+import type { ListPagesContext, ListUsersContext, TagCloudContext } from "./contexts";
 
 export interface DynamicModuleContext {
   listPages: ListPagesContext | null;
   listUsers: ListUsersContext | null;
+  tagCloud: TagCloudContext | null;
   fetchListPagesProvided: boolean;
   fetchListUsersProvided: boolean;
+  fetchTagCloudProvided: boolean;
 }
 
 export interface DynamicModuleIds {
   listPagesId: number;
   listUsersId: number;
+  tagCloudId: number;
 }
 
 export interface DynamicModuleResolution {
@@ -75,11 +79,32 @@ export function resolveDynamicModuleElement(
     };
   }
 
+  if (isTagCloudModule(element.data)) {
+    const elements: Element[] = [];
+    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 };
 }
 
 export function countDynamicModules(elements: Element[]): DynamicModuleIds {
-  const counts: DynamicModuleIds = { listPagesId: 0, listUsersId: 0 };
+  const counts: DynamicModuleIds = { listPagesId: 0, listUsersId: 0, tagCloudId: 0 };
   walkElements(elements, (element) => {
     if (element.element !== "module") return;
 
@@ -87,6 +112,8 @@ export function countDynamicModules(elements: Element[]): DynamicModuleIds {
       counts.listPagesId++;
     } else if (isListUsersModule(element.data)) {
       counts.listUsersId++;
+    } else if (isTagCloudModule(element.data)) {
+      counts.tagCloudId++;
     }
   });
   return counts;

package/src/parser/rules/block/module/resolution/walk-resolve.ts

@@ -1,7 +1,7 @@
 import type { Element } from "@wdprlib/ast";
 import { mapElementChildrenWithState } from "../walk";
 import { isIfTagsElement, resolveIfTags, type IfTagsData } from "../iftags/resolve";
-import type { ListPagesContext, ListUsersContext } from "./contexts";
+import type { ListPagesContext, ListUsersContext, TagCloudContext } from "./contexts";
 import { countDynamicModules, resolveDynamicModuleElement } from "./dynamic-modules";
 
 /**
@@ -10,19 +10,24 @@ import { countDynamicModules, resolveDynamicModuleElement } from "./dynamic-modu
 export interface WalkContext {
   listPages: ListPagesContext | null;
   listUsers: ListUsersContext | null;
+  tagCloud: TagCloudContext | null;
   /** Whether fetchListPages callback was provided, even if no data returned. */
   fetchListPagesProvided: boolean;
   /** Whether fetchListUsers callback was provided, even if no data returned. */
   fetchListUsersProvided: boolean;
+  /** Whether fetchTagCloud callback was provided, even if no data returned. */
+  fetchTagCloudProvided: boolean;
   pageTags: string[] | null;
   listPagesIdCounter: number;
   listUsersIdCounter: number;
+  tagCloudIdCounter: number;
 }
 
 export interface WalkResult {
   elements: Element[];
   nextListPagesId: number;
   nextListUsersId: number;
+  nextTagCloudId: number;
 }
 
 /**
@@ -32,13 +37,19 @@ export function walkAndResolve(elements: Element[], ctx: WalkContext): WalkResul
   const result: Element[] = [];
   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;
     }
 
@@ -52,20 +63,24 @@ export function walkAndResolve(elements: Element[], ctx: WalkContext): WalkResul
             ...ctx,
             listPagesIdCounter: listPagesId,
             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,
+          tagCloudIdCounter: tagCloudId,
         });
         result.push({
           element: "if-tags",
@@ -76,24 +91,27 @@ export function walkAndResolve(elements: Element[], ctx: WalkContext): WalkResul
         });
         listPagesId = childResult.nextListPagesId;
         listUsersId = childResult.nextListUsersId;
+        tagCloudId = childResult.nextTagCloudId;
       }
       continue;
     }
 
     const mapped = mapElementChildrenWithState(
       element,
-      { listPagesId, listUsersId },
+      { listPagesId, listUsersId, tagCloudId },
       (children, state) => {
         const childResult = walkAndResolve(children, {
           ...ctx,
           listPagesIdCounter: state.listPagesId,
           listUsersIdCounter: state.listUsersId,
+          tagCloudIdCounter: state.tagCloudId,
         });
         return {
           elements: childResult.elements,
           state: {
             listPagesId: childResult.nextListPagesId,
             listUsersId: childResult.nextListUsersId,
+            tagCloudId: childResult.nextTagCloudId,
           },
         };
       },
@@ -101,7 +119,13 @@ export function walkAndResolve(elements: Element[], ctx: WalkContext): WalkResul
     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,
+  };
 }