@code.store/arcxp-sdk-ts 4.49.0 → 5.0.0-beta

package/dist/index.cjs

@@ -0,0 +1,1905 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var axios = require('axios');
+var rateLimit = require('axios-rate-limit');
+var axiosRetry = require('axios-retry');
+var ws = require('ws');
+var FormData = require('form-data');
+var encode = require('base32-encode');
+var uuid = require('uuid');
+var nodeHtmlParser = require('node-html-parser');
+var htmlEntities = require('html-entities');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var rateLimit__namespace = /*#__PURE__*/_interopNamespaceDefault(rateLimit);
+var ws__namespace = /*#__PURE__*/_interopNamespaceDefault(ws);
+
+const safeJSONStringify = (data) => {
+    try {
+        return JSON.stringify(data) || '';
+    }
+    catch {
+        return '';
+    }
+};
+const AxiosResponseErrorInterceptor = (errorConstructor) => {
+    return [
+        (response) => response,
+        (error) => {
+            throw errorConstructor(error);
+        },
+    ];
+};
+
+class ArcError extends Error {
+    constructor(service, e) {
+        const ratelimitRemaining = e.response?.headers['arcpub-ratelimit-remaining'];
+        const ratelimitReset = e.response?.headers['arcpub-ratelimit-reset'];
+        const data = {
+            name: `${service}Error`,
+            message: e.message,
+            responseData: e.response?.data,
+            responseStatus: e.response?.status,
+            responseConfig: e.response?.config,
+            ratelimitRemaining,
+            ratelimitReset,
+            service,
+        };
+        const message = safeJSONStringify(data);
+        super(message);
+        Object.assign(this, data);
+        this.stack = e.stack;
+    }
+}
+
+class ArcAbstractAPI {
+    constructor(options) {
+        this.name = this.constructor.name;
+        this.token = '';
+        this.host = '';
+        this.headers = {
+            Authorization: '',
+        };
+        this.host = `api.${options.credentials.organizationName}.arcpublishing.com`;
+        this.token = `Bearer ${options.credentials.accessToken}`;
+        this.headers.Authorization = this.token;
+        const instance = axios.create({
+            baseURL: `https://${this.host}/${options.apiPath}`,
+            headers: this.headers,
+        });
+        // apply rate limiting
+        this.client = rateLimit__namespace.default(instance, { maxRPS: options.maxRPS || 10 });
+        // apply retry
+        const retry = typeof axiosRetry === 'function' ? axiosRetry : axiosRetry.default;
+        retry(this.client, {
+            retries: 5,
+            retryDelay: axiosRetry.exponentialDelay,
+            retryCondition: (err) => this.retryCondition(err),
+        });
+        // wrap response errors
+        this.client.interceptors.response.use(...AxiosResponseErrorInterceptor((e) => {
+            if (e instanceof ArcError)
+                return e;
+            return new ArcError(this.name, e);
+        }));
+    }
+    setMaxRPS(rps) {
+        this.client.setMaxRPS(rps);
+    }
+    retryCondition(error) {
+        const status = error.response?.status;
+        switch (status) {
+            case axios.HttpStatusCode.RequestTimeout:
+            case axios.HttpStatusCode.TooManyRequests:
+            case axios.HttpStatusCode.InternalServerError:
+            case axios.HttpStatusCode.BadGateway:
+            case axios.HttpStatusCode.ServiceUnavailable:
+            case axios.HttpStatusCode.GatewayTimeout:
+                return true;
+            default:
+                return false;
+        }
+    }
+}
+
+class ArcAuthor extends ArcAbstractAPI {
+    constructor(options) {
+        super({ ...options, apiPath: 'author' });
+    }
+    async listAuthors(params) {
+        const { data } = await this.client.get('/v2/author-service', { params });
+        return data;
+    }
+    async delete(userId) {
+        const { data } = await this.client.delete(`/v2/author-service/${userId}`);
+        return data;
+    }
+}
+
+class ArcContentOps extends ArcAbstractAPI {
+    constructor(options) {
+        super({ ...options, apiPath: 'contentops/v1' });
+    }
+    async schedulePublish(payload) {
+        const { data } = await this.client.put('/publish', payload);
+        return data;
+    }
+    async scheduleUnpublish(payload) {
+        const { data } = await this.client.put('/unpublish', payload);
+        return data;
+    }
+    async unscheduleUnpublish(payload) {
+        const { data } = await this.client.put('/unschedule_unpublish', payload);
+        return data;
+    }
+    async unschedulePublish(payload) {
+        const { data } = await this.client.put('/unschedule_publish', payload);
+        return data;
+    }
+}
+
+class ArcContent extends ArcAbstractAPI {
+    constructor(options) {
+        super({ ...options, apiPath: 'content/v4' });
+    }
+    async getStory(params) {
+        const { data } = await this.client.get('/stories', { params });
+        return data;
+    }
+    async search(params) {
+        const { data } = await this.client.get('/search', { params });
+        return data;
+    }
+    async scan(params) {
+        const { data } = await this.client.get('/scan', { params });
+        return data;
+    }
+    async getStoriesByIds(params) {
+        const { data } = await this.client.get('/ids', {
+            params: { ...params, ids: params.ids.join(',') },
+        });
+        return data;
+    }
+}
+
+class Custom extends ArcAbstractAPI {
+    constructor(options) {
+        super({ ...options, apiPath: '' });
+    }
+    async request(endpoint, config = {}) {
+        const response = await this.client.request({
+            url: endpoint,
+            ...config,
+        });
+        return response;
+    }
+}
+
+class ArcDraft extends ArcAbstractAPI {
+    constructor(options) {
+        super({ ...options, apiPath: 'draft/v1' });
+    }
+    async generateId(id) {
+        const { data } = await this.client.get('/arcuuid', { params: { id } });
+        return data.id;
+    }
+    async createDocument(ans, type = 'story') {
+        const { data } = await this.client.post(`/${type}`, ans);
+        return data;
+    }
+    async publishDocument(id, type = 'story') {
+        const { data } = await this.client.post(`/${type}/${id}/revision/published`);
+        return data;
+    }
+    async unpublishDocument(id, type = 'story') {
+        const { data } = await this.client.delete(`/${type}/${id}/revision/published`);
+        return data;
+    }
+    async deleteDocument(id, type = 'story') {
+        const { data } = await this.client.delete(`/${type}/${id}`);
+        return data;
+    }
+    async getPublishedRevision(id, type = 'story') {
+        const { data } = await this.client.get(`/${type}/${id}/revision/published`);
+        return data;
+    }
+    async getDraftRevision(id, type = 'story') {
+        const { data } = await this.client.get(`/${type}/${id}/revision/draft`);
+        return data;
+    }
+    async getCirculations(id, type = 'story', after) {
+        const { data } = await this.client.get(`/${type}/${id}/circulation`, { params: { after } });
+        return data;
+    }
+    async getRevisions(id, type = 'story', after) {
+        const { data } = await this.client.get(`/${type}/${id}/revision`, { params: { after } });
+        return data;
+    }
+    async getRevision(id, revisionId, type = 'story') {
+        const { data } = await this.client.get(`/${type}/${id}/revision/${revisionId}`);
+        return data;
+    }
+    async createRedirect(website, websiteUrl, payload) {
+        const { data } = await this.client.post(`/redirect/${website}/${websiteUrl}`, payload);
+        return data;
+    }
+    async getRedirect(website, websiteUrl) {
+        const { data } = await this.client.get(`/redirect/${website}/${websiteUrl}`);
+        return data;
+    }
+    async updateDraftRevision(id, payload, type = 'story') {
+        const { data } = await this.client.put(`/${type}/${id}/revision/draft`, payload);
+        return data;
+    }
+}
+
+class GlobalSettings extends ArcAbstractAPI {
+    constructor(options) {
+        super({ ...options, apiPath: 'settings/v1' });
+    }
+    async getDistributors(params) {
+        const { data } = await this.client.get('/distributor', { params });
+        return data;
+    }
+    async createDistributors(payload) {
+        const { data } = await this.client.post('/distributor', payload);
+        return data;
+    }
+}
+
+class ArcIdentity extends ArcAbstractAPI {
+    constructor(options) {
+        super({ ...options, apiPath: 'identity/api/v1' });
+    }
+    async migrateBatch(payload) {
+        const { data } = await this.client.post('/migrate', payload);
+        return data;
+    }
+    async *migrateBatchGenerator(payload, batchSize = 100) {
+        const copy = [...payload.records];
+        while (copy.length) {
+            const records = copy.splice(0, batchSize);
+            const response = await this.migrateBatch({ records });
+            yield response;
+        }
+    }
+    async getUser(id) {
+        const { data } = await this.client.get(`/user?search=uuid=${id}`);
+        return data;
+    }
+    async getUserByEmail(email) {
+        const { data } = await this.client.get(`/user?search=email=${email}`);
+        return data;
+    }
+    async updateUserProfile(id, payload) {
+        const { data } = await this.client.patch(`/profile/${id}`, payload);
+        return data;
+    }
+}
+
+const importNodeModule = async (moduleId) => await import(moduleId);
+const modules = {
+    // make it like that so static analyzer of webpack won't bundle it
+    fs: () => importNodeModule('node:fs'),
+    path: () => importNodeModule('node:path'),
+    form_data: () => importNodeModule('form-data'),
+};
+
+var platform = {
+    ...modules,
+};
+
+class ArcIFX extends ArcAbstractAPI {
+    constructor(options) {
+        super({ ...options, apiPath: 'ifx/api/v1' });
+    }
+    async createIntegration(payload) {
+        await this.client.post('/admin/integration', payload);
+    }
+    async updateIntegration(integrationName, payload) {
+        await this.client.put(`/admin/integration/${integrationName}`, payload);
+    }
+    async deleteIntegration(integrationName, token) {
+        await this.client.delete(`/admin/integration/${integrationName}`, { params: { token } });
+    }
+    async generateDeleteIntegrationToken(integrationName) {
+        const response = await this.client.get(`/admin/integration/${integrationName}/token`);
+        return response.data;
+    }
+    async getIntegrations() {
+        const { data } = await this.client.get('/admin/integrations');
+        return data;
+    }
+    async getJobs(integrationName) {
+        const { data } = await this.client.get(`/admin/jobs/status/${integrationName}`);
+        return data;
+    }
+    async getStatus(integrationName) {
+        const { data } = await this.client.get(`/admin/integration/${integrationName}/provisionStatus`);
+        return data;
+    }
+    async initializeQuery(integrationName, query) {
+        const { data } = await this.client.get(`/admin/logs/integration/${integrationName}?${query}`);
+        return data;
+    }
+    async getLogs(queryId, raw = true) {
+        const { data } = await this.client.get('/admin/logs/results', { params: { queryId, raw } });
+        return data;
+    }
+    async subscribe(payload) {
+        const { data } = await this.client.post('/admin/events/subscriptions', payload);
+        return data;
+    }
+    async updateSubscription(payload) {
+        const { data } = await this.client.put('/admin/events/subscriptions', payload);
+        return data;
+    }
+    async getSubscriptions() {
+        const { data } = await this.client.get('/admin/events/subscriptions');
+        return data;
+    }
+    async addSecret(payload) {
+        const { data } = await this.client.post(`/admin/secret?integrationName=${payload.integrationName}`, {
+            secretName: payload.secretName,
+            secretValue: payload.secretValue,
+        });
+        return data;
+    }
+    async getSecrets(integrationName) {
+        const { data } = await this.client.get(`/admin/secret?integrationName=${integrationName}`);
+        return data;
+    }
+    async getBundles(integrationName) {
+        const { data } = await this.client.get(`/admin/bundles/${integrationName}`);
+        return data;
+    }
+    async uploadBundle(integrationName, name, bundlePath) {
+        const fs = await platform.fs();
+        const FormData = await platform.form_data();
+        const form = new FormData();
+        console.log('platform', platform);
+        console.log(form);
+        const bundle = fs.createReadStream(bundlePath);
+        form.append('bundle', bundle);
+        form.append('name', name);
+        const { data } = await this.client.post(`/admin/bundles/${integrationName}`, form, {
+            headers: form.getHeaders(),
+        });
+        return data;
+    }
+    async deployBundle(integrationName, name) {
+        const { data } = await this.client.post(`/admin/bundles/${integrationName}/deploy/${name}`);
+        return data;
+    }
+    async promoteBundle(integrationName, version) {
+        const { data } = await this.client.post(`/admin/bundles/${integrationName}/promote/${version}`);
+        return data;
+    }
+}
+
+class ArcMigrationCenter extends ArcAbstractAPI {
+    constructor(options) {
+        super({ ...options, apiPath: 'migrations/v3' });
+    }
+    async summary(params) {
+        const { data, headers } = await this.client.get('/report/summary', { params });
+        const nextFromId = headers['amc-record-id'];
+        return { records: data, nextFromId };
+    }
+    async detailed(params) {
+        const { data } = await this.client.get('/report/detail', { params });
+        return data;
+    }
+    async count(params) {
+        const { data } = await this.client.get('/report/status/count', {
+            params: {
+                startDate: params?.startDate?.toISOString(),
+                endDate: params?.endDate?.toISOString(),
+            },
+        });
+        return data;
+    }
+    async postAns(params, payload) {
+        const { data } = await this.client.post('/content/ans', payload, { params });
+        return data;
+    }
+    async getAns(params) {
+        const { data } = await this.client.get('/content/ans', { params });
+        return data;
+    }
+    async getRemainingTime(params) {
+        const { data } = await this.client.get('/report/remaining-time', { params });
+        return data;
+    }
+    async getRecentGroupIds() {
+        const { data } = await this.client.get('/report/group-ids');
+        return data;
+    }
+}
+
+class ArcProtoCenter extends ArcAbstractAPI {
+    constructor(options) {
+        super({ ...options, apiPath: 'photo/api' });
+    }
+    async getImageDataById(imageId) {
+        const { data } = await this.client.get(`/v2/photos/${imageId}`);
+        return data;
+    }
+    async uploadImageANS(image) {
+        const FormData = await platform.form_data();
+        const form = new FormData();
+        form.append('ans', JSON.stringify(image), {
+            filename: 'ans.json',
+            contentType: 'application/json',
+        });
+        const { data } = await this.client.post('/v2/photos', form, { headers: form.getHeaders() });
+        return data;
+    }
+    async uploadImageStream(readableStream, options) {
+        const path = await platform.path();
+        const FormData = await platform.form_data();
+        const form = new FormData();
+        const contentType = options?.contentType ?? 'application/octet-stream';
+        const filename = path.basename(String(options?.filename || readableStream.path || 'file.jpg'));
+        form.append('file', readableStream, {
+            filename: filename,
+            contentType,
+        });
+        const { data } = await this.client.post('/v2/photos', form, { headers: form.getHeaders() });
+        return data;
+    }
+    async deleteImage(imageId) {
+        const { data } = await this.client.delete(`/v2/photos/${imageId}`);
+        return data;
+    }
+    async deleteGallery(galleryId) {
+        const { data } = await this.client.delete(`/v2/galleries/${galleryId}`);
+        return data;
+    }
+    async getImages(params) {
+        const { data } = await this.client.get('/v2/photos', { params });
+        return data;
+    }
+    async getGalleries(params) {
+        const { data } = await this.client.get('/v2/galleries', { params });
+        return data;
+    }
+    async getGallery(galleryId) {
+        const { data } = await this.client.get(`/v2/galleries/${galleryId}`);
+        return data;
+    }
+    async updateImage(imageId, photoDto) {
+        const { data } = await this.client.put(`/v2/photos/${imageId}`, photoDto);
+        return data;
+    }
+}
+
+class ArcRedirect extends ArcAbstractAPI {
+    constructor(options) {
+        super({ ...options, apiPath: 'delivery-api/v1/cloudlet/redirector/site' });
+    }
+    async getRedirects(orgSiteEnv) {
+        const { data } = await this.client.get(`/${orgSiteEnv}/rule?limit=1000`);
+        return data;
+    }
+    async updateArcRedirectRule(orgSiteEnv, redirectID, redirectRuleContent) {
+        const { data } = await this.client.put(`/${orgSiteEnv}/rule/${redirectID}`, redirectRuleContent);
+        return data;
+    }
+    async activateRedirectsVersion(orgSiteEnv) {
+        const { data } = await this.client.post(`/${orgSiteEnv}/version`);
+        return data;
+    }
+}
+
+class WsClient {
+    constructor(address, options) {
+        this.address = address;
+        this.options = options;
+        this._closing = false;
+    }
+    async connect() {
+        if (this.socket && this.socket.readyState === this.socket.OPEN)
+            return;
+        const socket = new ws__namespace.WebSocket(this.address, this.options);
+        this._closing = false;
+        socket.onclose = (event) => this.close(event);
+        await new Promise((resolve, reject) => {
+            socket.onerror = (error) => reject(error);
+            socket.onopen = () => resolve(true);
+        });
+        socket.onmessage = ({ data }) => {
+            let message;
+            try {
+                message = JSON.parse(data.toString());
+            }
+            catch {
+                throw new Error('failed to parse message');
+            }
+            this.onMessage?.(message);
+        };
+        this.socket = socket;
+        this.onOpen?.();
+    }
+    close(event) {
+        if (this._closing)
+            return;
+        this._closing = true;
+        this.socket?.close();
+        this.onClose?.(event);
+    }
+    async send(data) {
+        this.throwIfNotOpen();
+        await new Promise((resolve, reject) => {
+            this.socket.send(data, (error) => {
+                error ? reject(error) : resolve(undefined);
+            });
+        });
+    }
+    throwIfNotOpen() {
+        if (!this.socket) {
+            throw new Error('Client is not connected');
+        }
+        const { readyState, OPEN } = this.socket;
+        if (readyState === OPEN)
+            return;
+        if (readyState < OPEN) {
+            throw new Error('socket is still connecting');
+        }
+        if (readyState > OPEN) {
+            throw new Error('socket was closed');
+        }
+    }
+}
+
+class ArcRetailEvents {
+    constructor(options) {
+        this.options = options;
+    }
+    createWsClient(index = '0') {
+        const address = `wss://api.${this.options.credentials.organizationName}.arcpublishing.com/retail/api/v1/event/stream/${index}`;
+        const headers = {
+            Authorization: `Bearer ${this.options.credentials.accessToken}`,
+        };
+        return new WsClient(address, { headers });
+    }
+}
+
+class ArcSales extends ArcAbstractAPI {
+    constructor(options) {
+        super({ ...options, apiPath: 'sales/api/v1' });
+    }
+    async migrate(payload) {
+        const form = new FormData();
+        form.append('file', JSON.stringify(payload), { filename: 'subs.json', contentType: 'application/json' });
+        const { data } = await this.client.post('/migrate', form, {
+            headers: {
+                ...form.getHeaders(),
+            },
+        });
+        return data;
+    }
+}
+
+class ArcSigningService extends ArcAbstractAPI {
+    constructor(options) {
+        super({ ...options, apiPath: 'signing-service' });
+    }
+    async sign(service, serviceVersion, imageId) {
+        const { data } = await this.client.get(`/v2/sign/${service}/${serviceVersion}?value=${encodeURI(imageId)}`);
+        return data;
+    }
+}
+
+class ArcSite extends ArcAbstractAPI {
+    constructor(options) {
+        super({ ...options, apiPath: 'site/v3' });
+    }
+    async getSections(params) {
+        const { data } = await this.client.get(`/website/${params.website}/section`, {
+            params: { _website: params.website, ...params },
+        });
+        return data;
+    }
+    async getSection(id, website) {
+        const { data } = await this.client.get(`/website/${website}/section?_id=${id}`);
+        return data;
+    }
+    async deleteSection(id, website) {
+        await this.client.delete(`/website/${website}/section?_id=${id}`);
+    }
+    async putSection(section) {
+        const { data } = await this.client.put(`/website/${section.website}/section?_id=${section._id}`, section);
+        return data;
+    }
+    async getWebsites() {
+        const { data } = await this.client.get('/website');
+        return data;
+    }
+    async putLink(link) {
+        const { data } = await this.client.put(`/website/${link._website}/link/${link._id}`, link);
+        return data;
+    }
+    async deleteLink(id, website) {
+        const { data } = await this.client.delete(`/website/${website}/link/${id}`);
+        return data;
+    }
+    async getLinks(params) {
+        const { data } = await this.client.get(`/website/${params.website}/link`, { params });
+        return data;
+    }
+}
+
+class ArcTags extends ArcAbstractAPI {
+    constructor(options) {
+        super({ ...options, apiPath: 'tags' });
+    }
+    async getAllTags(params) {
+        const { data } = await this.client.get('/', { params });
+        return data;
+    }
+    /*
+     * @Deprecated
+     * May return incorrect results
+     * Use searchTagsV2 instead
+     */
+    async searchTags(params) {
+        const { data } = await this.client.get('/search', { params });
+        return data;
+    }
+    async searchTagsV2(params) {
+        const { data } = await this.client.get('/v2/search', { params });
+        return data;
+    }
+    async addTags(payload) {
+        const { data } = await this.client.post('/add', payload);
+        return data;
+    }
+    async deleteTags(payload) {
+        const { data } = await this.client.post('/delete', payload);
+        return data;
+    }
+}
+
+class ArcWebsked extends ArcAbstractAPI {
+    constructor(options) {
+        super({ ...options, apiPath: 'websked' });
+    }
+    async reportStatusChange(payload) {
+        const { data } = await this.client.post('/tasks/workflowStatusChange', payload);
+        return data;
+    }
+    async createTask(payload) {
+        const { data } = await this.client.post('/tasks', payload);
+        return data;
+    }
+    async getEditionTimes(publicationId, startDate, endDate, numEditions = 1) {
+        const { data } = await this.client.get(`/publications/${publicationId}/editionTimes`, {
+            params: { startDate, endDate, numEditions },
+        });
+        return data;
+    }
+    async getSectionStories(publicationId, sectionId, timestamp, includeStories = true) {
+        const { data } = await this.client.get(`/publications/${publicationId}/sections/${sectionId}/editions/${timestamp}`, { params: { includeStories } });
+        return data;
+    }
+    async getSectionEditions(publicationId, sectionId, startDate, numEditions = 100) {
+        const { data } = await this.client.get(`/publications/${publicationId}/sections/${sectionId}/editions`, {
+            params: { startDate, numEditions },
+        });
+        return data;
+    }
+    async getPublications(nameRegex) {
+        const { data } = await this.client.get('/publications', { params: { nameRegex } });
+        return data;
+    }
+    async getPublicationById(publicationId) {
+        const { data } = await this.client.get(`/publications/${publicationId}`);
+        return data;
+    }
+    async getStatuses() {
+        const { data } = await this.client.get('/statuses');
+        return data;
+    }
+}
+
+const ArcAPI = (options) => {
+    const API = {
+        Author: new ArcAuthor(options),
+        Draft: new ArcDraft(options),
+        Identity: new ArcIdentity(options),
+        IFX: new ArcIFX(options),
+        Redirect: new ArcRedirect(options),
+        MigrationCenter: new ArcMigrationCenter(options),
+        Sales: new ArcSales(options),
+        Site: new ArcSite(options),
+        Websked: new ArcWebsked(options),
+        Content: new ArcContent(options),
+        SigningService: new ArcSigningService(options),
+        PhotoCenter: new ArcProtoCenter(options),
+        GlobalSettings: new GlobalSettings(options),
+        Tags: new ArcTags(options),
+        ContentOps: new ArcContentOps(options),
+        RetailEvents: new ArcRetailEvents(options),
+        Custom: new Custom(options),
+    };
+    API.MigrationCenter.setMaxRPS(8);
+    API.Draft.setMaxRPS(4);
+    API.Content.setMaxRPS(3);
+    return API;
+};
+
+/* eslint-disable */
+/**
+ * This file was automatically generated by json-schema-to-typescript.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run json-schema-to-typescript to regenerate this file.
+ */
+
+var ansTypes = /*#__PURE__*/Object.freeze({
+    __proto__: null
+});
+
+var utils = /*#__PURE__*/Object.freeze({
+    __proto__: null
+});
+
+var ANSType;
+(function (ANSType) {
+    ANSType["Story"] = "story";
+    ANSType["Video"] = "video";
+    ANSType["Tag"] = "tag";
+    ANSType["Author"] = "author";
+    ANSType["Gallery"] = "gallery";
+    ANSType["Image"] = "image";
+    ANSType["Redirect"] = "redirect";
+})(ANSType || (ANSType = {}));
+var MigrationStatus;
+(function (MigrationStatus) {
+    MigrationStatus["Success"] = "Success";
+    MigrationStatus["Queued"] = "Queued";
+    MigrationStatus["Circulated"] = "Circulated";
+    MigrationStatus["Published"] = "Published";
+    MigrationStatus["Scheduled"] = "Scheduled";
+    MigrationStatus["FailVideo"] = "FailVideo";
+    MigrationStatus["FailImage"] = "FailImage";
+    MigrationStatus["FailPhoto"] = "FailPhoto";
+    MigrationStatus["FailStory"] = "FailStory";
+    MigrationStatus["FailGallery"] = "FailGallery";
+    MigrationStatus["FailAuthor"] = "FailAuthor";
+    MigrationStatus["FailTag"] = "FailTag";
+    MigrationStatus["ValidationFailed"] = "ValidationFailed";
+})(MigrationStatus || (MigrationStatus = {}));
+var SummarySortBy;
+(function (SummarySortBy) {
+    SummarySortBy["CreateDate"] = "createDate";
+    SummarySortBy["UpdateDate"] = "updateDate";
+    SummarySortBy["Id"] = "id";
+})(SummarySortBy || (SummarySortBy = {}));
+var SummarySortOrder;
+(function (SummarySortOrder) {
+    SummarySortOrder["ASC"] = "ASC";
+    SummarySortOrder["DESC"] = "DESC";
+})(SummarySortOrder || (SummarySortOrder = {}));
+
+var index$3 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    ANS: ansTypes,
+    get ANSType () { return ANSType; },
+    get MigrationStatus () { return MigrationStatus; },
+    get SummarySortBy () { return SummarySortBy; },
+    get SummarySortOrder () { return SummarySortOrder; },
+    TypeUtils: utils
+});
+
+const reference = (ref) => {
+    return {
+        _id: ref.id,
+        type: 'reference',
+        referent: {
+            ...ref,
+        },
+    };
+};
+
+var ANS = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    reference: reference
+});
+
+const ContentElement = {
+    divider: () => {
+        return {
+            type: 'divider',
+        };
+    },
+    text: (content, alignment = 'left') => {
+        return {
+            type: 'text',
+            content,
+            alignment: alignment || undefined,
+        };
+    },
+    quote: (items, citation = '', subtype = 'pullquote') => {
+        return {
+            type: 'quote',
+            subtype,
+            citation: {
+                type: 'text',
+                content: citation,
+            },
+            content_elements: items,
+        };
+    },
+    interstitial_link: (url, content) => {
+        return {
+            type: 'interstitial_link',
+            url,
+            content,
+        };
+    },
+    header: (content, level) => {
+        return {
+            type: 'header',
+            content,
+            level,
+        };
+    },
+    raw_html: (content) => {
+        return {
+            type: 'raw_html',
+            content,
+        };
+    },
+    gallery: (id) => {
+        return {
+            type: 'reference',
+            referent: {
+                type: 'gallery',
+                id,
+            },
+        };
+    },
+    list: (type, items) => {
+        return {
+            type: 'list',
+            list_type: type,
+            items,
+        };
+    },
+    link_list: (title, links) => {
+        return {
+            type: 'link_list',
+            title,
+            items: links.map(({ content, url }) => {
+                return {
+                    type: 'interstitial_link',
+                    content,
+                    url,
+                };
+            }),
+        };
+    },
+    image: (id, properties) => {
+        return {
+            referent: {
+                id,
+                type: 'image',
+                referent_properties: {
+                    _id: id,
+                    type: 'image',
+                    ...properties,
+                },
+            },
+            type: 'reference',
+        };
+    },
+    jwPlayer: (id) => {
+        return {
+            embed: {
+                config: {},
+                id,
+                url: 'https://cdn.jwplayer.com/players',
+            },
+            subtype: 'jw_player',
+            type: 'custom_embed',
+        };
+    },
+    twitter: (id, provider = 'https://publish.twitter.com/oembed?url=') => {
+        return {
+            referent: {
+                id,
+                provider,
+                service: 'oembed',
+                type: 'twitter',
+            },
+            type: 'reference',
+        };
+    },
+    youtube: (id, provider = 'https://www.youtube.com/oembed?url=') => {
+        return {
+            referent: {
+                id,
+                provider,
+                service: 'oembed',
+                type: 'youtube',
+            },
+            type: 'reference',
+        };
+    },
+    facebook_video: (id, provider = 'https://www.facebook.com/plugins/post/oembed.json/?url=') => {
+        return {
+            referent: {
+                id,
+                provider,
+                service: 'oembed',
+                type: 'facebook-video',
+            },
+            type: 'reference',
+        };
+    },
+    facebook_post: (id, provider = 'https://www.facebook.com/plugins/post/oembed.json/?url=') => {
+        return {
+            referent: {
+                id,
+                provider,
+                service: 'oembed',
+                type: 'facebook-post',
+            },
+            type: 'reference',
+        };
+    },
+    soundcloud: (id, provider = 'https://soundcloud.com/oembed.json/?url=') => {
+        return {
+            referent: {
+                id,
+                provider,
+                service: 'oembed',
+                type: 'soundcloud',
+            },
+            type: 'reference',
+        };
+    },
+    vimeo: (id, provider = 'https://vimeo.com/api/oembed.json?url=') => {
+        return {
+            referent: {
+                id,
+                provider,
+                service: 'oembed',
+                type: 'vimeo',
+            },
+            type: 'reference',
+        };
+    },
+    instagram: (id, provider = 'https://api.instagram.com/oembed?url=') => {
+        return {
+            referent: {
+                id,
+                provider,
+                service: 'oembed',
+                type: 'instagram',
+            },
+            type: 'reference',
+        };
+    },
+    dailymotion: (id, provider = 'https://www.dailymotion.com/services/oembed?url=') => {
+        return {
+            referent: {
+                id,
+                provider,
+                service: 'oembed',
+                type: 'dailymotion',
+            },
+            type: 'reference',
+        };
+    },
+    tiktok: (id, provider = 'https://www.tiktok.com/oembed?url=') => {
+        return {
+            referent: {
+                id,
+                provider,
+                service: 'oembed',
+                type: 'tiktok',
+            },
+            type: 'reference',
+        };
+    },
+    issuu: (id, provider = 'https://issuu.com/oembed_wp?url=') => {
+        return {
+            referent: {
+                id,
+                provider,
+                service: 'oembed',
+                type: 'issuu',
+            },
+            type: 'reference',
+        };
+    },
+    kickstarter: (id, provider = 'https://www.kickstarter.com/services/oembed?url=') => {
+        return {
+            referent: {
+                id,
+                provider,
+                service: 'oembed',
+                type: 'kickstarter',
+            },
+            type: 'reference',
+        };
+    },
+    polldaddy: (id, provider = 'https://polldaddy.com/oembed/?url=') => {
+        return {
+            referent: {
+                id,
+                provider,
+                service: 'oembed',
+                type: 'polldaddy',
+            },
+            type: 'reference',
+        };
+    },
+};
+
+const socialRegExps = {
+    instagram: /(?:https?:\/\/)?(?:www.)?instagram.com\/?([a-zA-Z0-9\.\_\-]+)?\/([p]+)?([reel]+)?([tv]+)?([stories]+)?\/([a-zA-Z0-9\-\_\.]+)\/?([0-9]+)?/,
+    twitter: /https:\/\/(?:www\.)?twitter\.com\/[^\/]+\/status(?:es)?\/(\d+)/,
+    tiktok: /https:\/\/(?:m|www|vm)?\.?tiktok\.com\/((?:.*\b(?:(?:usr|v|embed|user|video)\/|\?shareId=|\&item_id=)(\d+))|\w+)/,
+    facebookPost: /https:\/\/www\.facebook\.com\/(photo(\.php|s)|permalink\.php|media|questions|notes|[^\/]+\/(activity|posts))[\/?].*$/,
+    facebookVideo: /https:\/\/www\.facebook\.com\/([^\/?].+\/)?video(s|\.php)[\/?].*/,
+};
+function match(url, regex) {
+    return url.match(regex)?.[0];
+}
+function youtubeURLParser(url = '') {
+    const regExp = /(?:youtube(?:-nocookie)?\.com\/(?:[^\/\n\s]+\/\S+\/|(?:v|e(?:mbed)?)\/|\S*?[?&]vi?=)|youtu\.be\/)([a-zA-Z0-9_-]{11})/;
+    const id = url?.match(regExp)?.[1];
+    if (id) {
+        return `https://youtu.be/${id}`;
+    }
+    const paylistMatch = url?.match(/[?&]list=([^#&?]+)/);
+    if (paylistMatch?.[1]) {
+        return `https://www.youtube.com/embed/videoseries?list=${paylistMatch?.[1]}`;
+    }
+    return undefined;
+}
+function twitterURLParser(url) {
+    return match(url, socialRegExps.twitter);
+}
+function instagramURLParser(url) {
+    return match(url, socialRegExps.instagram);
+}
+function tiktokURLParser(url) {
+    return match(url, socialRegExps.tiktok);
+}
+function facebookVideoURLParser(url) {
+    return match(url, socialRegExps.facebookVideo);
+}
+function facebookPostURLParser(url) {
+    return match(url, socialRegExps.facebookPost);
+}
+function createSocial(url = '') {
+    const embeds = [];
+    const instagram = instagramURLParser(url);
+    if (instagram) {
+        embeds.push(ContentElement.instagram(instagram));
+    }
+    const twitter = twitterURLParser(url);
+    if (twitter) {
+        embeds.push(ContentElement.twitter(twitter));
+    }
+    const tiktok = tiktokURLParser(url);
+    if (tiktok) {
+        embeds.push(ContentElement.tiktok(tiktok));
+    }
+    const youtube = youtubeURLParser(url);
+    if (youtube) {
+        embeds.push(ContentElement.youtube(youtube));
+    }
+    const facebookPost = facebookPostURLParser(url);
+    if (facebookPost) {
+        embeds.push(ContentElement.facebook_post(facebookPost));
+    }
+    const facebookVideo = facebookVideoURLParser(url);
+    if (facebookVideo) {
+        embeds.push(ContentElement.facebook_video(facebookVideo));
+    }
+    return embeds;
+}
+const randomId = () => `${new Date().toISOString()}-${Math.random()}`;
+
+var ContentElements = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    createSocial: createSocial,
+    facebookPostURLParser: facebookPostURLParser,
+    facebookVideoURLParser: facebookVideoURLParser,
+    instagramURLParser: instagramURLParser,
+    randomId: randomId,
+    tiktokURLParser: tiktokURLParser,
+    twitterURLParser: twitterURLParser,
+    youtubeURLParser: youtubeURLParser
+});
+
+const generateArcId = (identifier, orgHostname) => {
+    const namespace = uuid.v5(orgHostname, uuid.v5.DNS);
+    const buffer = uuid.v5(identifier, namespace, Buffer.alloc(16));
+    return encode(buffer, 'RFC4648', { padding: false });
+};
+/**
+ * Utility class for generating Arc IDs and source IDs
+ *
+ * @example
+ * ```ts
+ * const generator = new IdGenerator(['my-org']);
+ * const arcId = generator.getArcId('123'); // Generates a unique for 'my-org' Arc ID
+ * const sourceId = generator.getSourceId('123', ['my-site']); // Generates 'my-site-123'
+ * ```
+ */
+class IdGenerator {
+    constructor(namespaces) {
+        if (!namespaces.length) {
+            throw new Error('At least 1 namespace is required');
+        }
+        this.namespace = namespaces.join('-');
+    }
+    getArcId(id) {
+        return generateArcId(id.toString(), this.namespace);
+    }
+    getSourceId(id, prefixes = []) {
+        return [...prefixes, id].join('-');
+    }
+}
+
+var Id = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    IdGenerator: IdGenerator,
+    generateArcId: generateArcId
+});
+
+const ArcUtils = {
+    Id,
+    ANS,
+    ContentElements,
+};
+
+/**
+ * Base class for all arc entities, it provides common methods and properties
+ * If you want to create a new entity subtype you should extend this class
+ *
+ * Use case: You want to migrate stories from BBC
+ * You define `class BBCStory extends ArcDocument<ANS.AStory>` and implement all abstract methods
+ * Then you can override the specific methods to enrich the story with the data from BBC
+ *
+ * To migrate it call .migrate() method
+ */
+class Document {
+    constructor() {
+        this.ans = null;
+        this.circulations = [];
+    }
+    async init() {
+        // fetch necessary data and validate it here
+    }
+    async prepare() {
+        await this.init();
+        const payload = await this.payload();
+        const params = await this.params();
+        return { payload, params };
+    }
+    async payload() {
+        this.ans = await this.getAns();
+        this.circulations = await this.getCirculations();
+        return {
+            sourceId: await this.sourceId(),
+            sourceType: await this.sourceType(),
+            ANS: this.ans,
+            circulations: this.circulations,
+            arcAdditionalProperties: this.additionalProperties(),
+        };
+    }
+    async params() {
+        if (!this.websiteId()) {
+            throw new Error('Website is not initialized! get params() should be called after payload()!');
+        }
+        return {
+            website: await this.websiteId(),
+            groupId: await this.groupId(),
+            priority: this.priority(),
+        };
+    }
+    additionalProperties() {
+        return {
+            story: {
+                publish: false,
+            },
+        };
+    }
+    priority() {
+        return 'historical';
+    }
+    getDistributor() {
+        return;
+    }
+    getLanguage() {
+        return 'en-GB';
+    }
+    getComments() {
+        return;
+    }
+    async getSource() {
+        return {
+            name: 'code-store',
+            system: 'code-store',
+            source_id: await this.sourceId(),
+        };
+    }
+    getSubheadlines() {
+        return {
+            basic: '',
+        };
+    }
+    getDescription() {
+        return this.getSubheadlines();
+    }
+    formatDate(date) {
+        if (!date)
+            return;
+        return date.toISOString();
+    }
+    getDisplayDate() {
+        return new Date();
+    }
+    async getContentElements() {
+        return [];
+    }
+    getPublicationDate() {
+        return new Date();
+    }
+    getHeadlines() {
+        return {
+            basic: '',
+        };
+    }
+    getTags() {
+        return;
+    }
+    getSubtype() {
+        return;
+    }
+    getLabel() {
+        return;
+    }
+    getRelatedContent() {
+        return;
+    }
+    async getPromoItems() {
+        return;
+    }
+    getWebskedStatusCode() {
+        return;
+    }
+    getCreditsBy() {
+        return [];
+    }
+    getCirculations() {
+        return [];
+    }
+    getEditorNote() {
+        return;
+    }
+    getContentRestrictions() {
+        return;
+    }
+    getOwnerInformation() {
+        return;
+    }
+    getSyndication() {
+        return;
+    }
+    getSchedulingInformation() {
+        return;
+    }
+    getTaxonomy() {
+        return;
+    }
+}
+
+/**
+ * Base class for all arc stories, it provides common methods and properties
+ * If you want to create a new story subtype you should extend this class
+ *
+ * Use case: You want to migrate stories from BBC
+ * You define `class BBCStory extends ArcStory` and implement all abstract methods
+ * Then you need to override the specific methods to enrich the story with the data from BBC
+ *
+ * For example:
+ * To add tag to BBC stories you need to override
+ * protected getTags(): MaybePromise<ArcTypes.Story.Tag[]> {
+ *     return [{
+ *       slug: 'bbc',
+ *       text: 'bbc',
+ *     }];
+ * }
+ */
+class Story extends Document {
+    type() {
+        return 'story';
+    }
+    async getAns() {
+        const id = await this.arcId();
+        const version = this.version();
+        const type = this.type();
+        const publicationDate = await this.getPublicationDate();
+        const displayDate = await this.getDisplayDate();
+        const headlines = this.getHeadlines();
+        const subheadlines = this.getSubheadlines();
+        const description = this.getDescription();
+        const language = this.getLanguage();
+        const tags = await this.getTags();
+        const subtype = await this.getSubtype();
+        const label = await this.getLabel();
+        const by = await this.getCreditsBy();
+        const relatedContent = await this.getRelatedContent();
+        const editorNote = await this.getEditorNote();
+        const distributor = await this.getDistributor();
+        const promoItems = await this.getPromoItems();
+        const contentElements = await this.getContentElements();
+        const webskedStatusCode = await this.getWebskedStatusCode();
+        const websiteId = await this.websiteId();
+        const source = await this.getSource();
+        const comments = await this.getComments();
+        const legacyUrl = await this.legacyUrl();
+        const owner = await this.getOwnerInformation();
+        const syndication = await this.getSyndication();
+        const contentRestrictions = await this.getContentRestrictions();
+        const planning = await this.getSchedulingInformation();
+        const taxonomy = await this.getTaxonomy();
+        const additionalMetaProperties = await this.getMigrationMetaProperties();
+        return {
+            type,
+            _id: id,
+            version,
+            website: websiteId,
+            canonical_website: websiteId,
+            language,
+            subtype,
+            label,
+            editor_note: editorNote,
+            credits: {
+                by,
+            },
+            headlines,
+            subheadlines,
+            description,
+            distributor,
+            planning,
+            promo_items: promoItems,
+            related_content: relatedContent,
+            content_restrictions: contentRestrictions,
+            created_date: this.formatDate(new Date()),
+            first_publish_date: this.formatDate(publicationDate),
+            publish_date: this.formatDate(publicationDate),
+            display_date: this.formatDate(displayDate),
+            source,
+            comments,
+            owner,
+            syndication,
+            taxonomy: {
+                ...taxonomy,
+                tags,
+            },
+            workflow: {
+                status_code: webskedStatusCode,
+            },
+            content_elements: contentElements,
+            additional_properties: {
+                url: legacyUrl,
+                ...additionalMetaProperties,
+            },
+        };
+    }
+    async getMigrationMetaProperties() {
+        return {
+            // used in dashboard for migration
+            migration_source_id: await this.sourceId(),
+            migration_source_type: await this.sourceType(),
+            // used in dashboard to show the original url
+            migration_url: await this.legacyUrl(),
+            migration_group_id: await this.groupId(),
+        };
+    }
+}
+
+var index$2 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    Document: Document,
+    Story: Story
+});
+
+const BLOCK_ELEMENT_TAGS = [
+    'ADDRESS',
+    'ARTICLE',
+    'ASIDE',
+    'BLOCKQUOTE',
+    'DETAILS',
+    'DIV',
+    'DL',
+    'FIELDSET',
+    'FIGCAPTION',
+    'FIGURE',
+    'FOOTER',
+    'FORM',
+    'H1',
+    'H2',
+    'H3',
+    'H4',
+    'H5',
+    'H6',
+    'HEADER',
+    'HR',
+    'LINE',
+    'MAIN',
+    'MENU',
+    'NAV',
+    'OL',
+    'P',
+    'PARAGRAPH',
+    'PRE',
+    'SECTION',
+    'TABLE',
+    'UL',
+    'LI',
+    'BODY',
+    'HTML',
+];
+
+var html_constants = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    BLOCK_ELEMENT_TAGS: BLOCK_ELEMENT_TAGS
+});
+
+const isTextNode = (node) => {
+    return node instanceof nodeHtmlParser.TextNode;
+};
+const isHTMLElement = (node) => {
+    return node instanceof nodeHtmlParser.HTMLElement;
+};
+const isCommentNode = (node) => {
+    return node instanceof nodeHtmlParser.CommentNode;
+};
+const nodeTagIs = (node, name) => {
+    return isHTMLElement(node) && node.tagName?.toLowerCase() === name.toLowerCase();
+};
+const nodeTagIn = (node, names) => {
+    return isHTMLElement(node) && names.includes(node.tagName?.toLowerCase());
+};
+const isTextCE = (ce) => {
+    return ce?.type === 'text';
+};
+const decodeHTMLEntities = (str) => htmlEntities.decode(str);
+const htmlToText = (html, parseOptions) => {
+    if (!html)
+        return '';
+    const doc = nodeHtmlParser.parse(html, parseOptions);
+    return decodeHTMLEntities(doc.innerText);
+};
+const getHTMLElementAttribute = (e, key) => {
+    const value = e.getAttribute(key);
+    if (value)
+        return value;
+    return new URLSearchParams(e.rawAttrs.replaceAll(' ', '&')).get(key);
+};
+
+var html_utils = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    decodeHTMLEntities: decodeHTMLEntities,
+    getHTMLElementAttribute: getHTMLElementAttribute,
+    htmlToText: htmlToText,
+    isCommentNode: isCommentNode,
+    isHTMLElement: isHTMLElement,
+    isTextCE: isTextCE,
+    isTextNode: isTextNode,
+    nodeTagIn: nodeTagIn,
+    nodeTagIs: nodeTagIs
+});
+
+/**
+ * HTMLProcessor is responsible for parsing HTML content into structured content elements.
+ * It provides a flexible way to handle different HTML nodes and wrap text content.
+ *
+ * The processor can be extended with custom handlers for specific node types and
+ * wrappers for text content.
+ *
+ * @example
+ * ```ts
+ * // Create and initialize processor
+ * const processor = new HTMLProcessor();
+ * processor.init();
+ *
+ * // Parse HTML content
+ * const html = '<div><p>Some text</p><img src="image.jpg"></div>';
+ * const elements = await processor.parse(html);
+ * ```
+ *
+ * The processor comes with built-in handlers for common HTML elements like links,
+ * text formatting (i, u, strong), and block elements. Custom handlers can be added
+ * using the `handle()` and `wrap()` methods.
+ */
+class HTMLProcessor {
+    constructor() {
+        this.parallelProcessing = true;
+        this.handlers = {
+            node: new Map(),
+            wrap: new Map(),
+        };
+    }
+    init() {
+        // wrappers are used to wrap the content of nested text nodes
+        // in a specific way
+        this.wrap('link', (node, text) => {
+            if (nodeTagIn(node, ['a'])) {
+                const attributes = ['href', 'target', 'rel']
+                    .map((attr) => [attr, getHTMLElementAttribute(node, attr)])
+                    .filter(([_, value]) => value)
+                    .map(([key, value]) => `${key}="${value}"`)
+                    .join(' ');
+                return {
+                    ...text,
+                    content: `<a ${attributes}>${text.content}</a>`,
+                };
+            }
+        });
+        this.wrap('i', (node, text) => {
+            if (nodeTagIn(node, ['i'])) {
+                return {
+                    ...text,
+                    content: `<i>${text.content}</i>`,
+                };
+            }
+        });
+        this.wrap('u', (node, text) => {
+            if (nodeTagIn(node, ['u'])) {
+                return {
+                    ...text,
+                    content: `<u>${text.content}</u>`,
+                };
+            }
+        });
+        this.wrap('sup/sub', (node, text) => {
+            if (nodeTagIn(node, ['sup', 'sub'])) {
+                return {
+                    ...text,
+                    content: `<mark class="${node.tagName.toLowerCase()}">${text.content}</mark>`,
+                };
+            }
+        });
+        this.wrap('strong', (node, text) => {
+            if (nodeTagIn(node, ['strong', 'b'])) {
+                return {
+                    ...text,
+                    content: `<b>${text.content}</b>`,
+                };
+            }
+        });
+        this.wrap('center', (node, text) => {
+            if (nodeTagIn(node, ['center'])) {
+                return {
+                    ...text,
+                    alignment: 'center',
+                };
+            }
+        });
+        this.wrap('aligned-paragraph', (node, text) => {
+            if (nodeTagIn(node, ['p'])) {
+                const styleAttribute = getHTMLElementAttribute(node, 'style') || '';
+                if (!styleAttribute)
+                    return text;
+                if (styleAttribute.includes('text-align: right;')) {
+                    return {
+                        ...text,
+                        alignment: 'right',
+                    };
+                }
+                if (styleAttribute.includes('text-align: left;')) {
+                    return {
+                        ...text,
+                        alignment: 'left',
+                    };
+                }
+                if (styleAttribute.includes('text-align: center;')) {
+                    return {
+                        ...text,
+                        alignment: 'center',
+                    };
+                }
+                return text;
+            }
+        });
+        // handlers are used to handle specific nodes
+        // and return a list of content elements
+        this.handle('default', (node) => {
+            const noTag = isHTMLElement(node) && !node.tagName;
+            if (noTag ||
+                nodeTagIn(node, [
+                    'p',
+                    'a',
+                    'b',
+                    'sup',
+                    'sub',
+                    'span',
+                    'strong',
+                    'em',
+                    'i',
+                    'u',
+                    'section',
+                    'main',
+                    'div',
+                    'li',
+                    'center',
+                ])) {
+                return this.handleNested(node);
+            }
+        });
+        this.handle('headers', (node) => {
+            if (nodeTagIn(node, ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'])) {
+                return this.createHeader(node);
+            }
+        });
+        this.handle('text', (node) => {
+            if (isTextNode(node)) {
+                return this.createText(node);
+            }
+        });
+        this.handle('comment', (node) => {
+            if (isCommentNode(node)) {
+                return this.handleComment(node);
+            }
+        });
+        this.handle('list', async (node) => {
+            if (nodeTagIn(node, ['ul', 'ol'])) {
+                const listType = node.tagName === 'UL' ? 'unordered' : 'ordered';
+                return this.createList(node, listType);
+            }
+        });
+        this.handle('table', (node) => {
+            if (nodeTagIs(node, 'table')) {
+                return this.handleTable(node);
+            }
+        });
+        this.handle('iframe', (node) => {
+            if (nodeTagIs(node, 'iframe')) {
+                return this.handleIframe(node);
+            }
+        });
+        this.handle('img', (node) => {
+            if (nodeTagIs(node, 'img')) {
+                return this.handleImage(node);
+            }
+        });
+        this.handle('br', (node) => {
+            if (nodeTagIs(node, 'br')) {
+                return this.handleBreak(node);
+            }
+        });
+    }
+    handle(name, handler) {
+        if (this.handlers.node.has(name)) {
+            this.warn({ name }, `${name} node handler already set`);
+        }
+        this.handlers.node.set(name, handler);
+    }
+    wrap(name, handler) {
+        if (this.handlers.wrap.has(name)) {
+            this.warn({ name }, `${name} wrap handler already set`);
+        }
+        this.handlers.wrap.set(name, handler);
+    }
+    async parse(html) {
+        const doc = nodeHtmlParser.parse(html, { comment: true });
+        doc.removeWhitespace();
+        const elements = await this.process(doc);
+        const filtered = elements?.filter((e) => e.type !== 'divider');
+        return filtered || [];
+    }
+    addTextAdditionalProperties(c, parent) {
+        const additionalProperties = c.additional_properties || {};
+        const parentNodeIsBlockElement = this.isBlockElement(parent);
+        c.additional_properties = {
+            ...c.additional_properties,
+            isBlockElement: additionalProperties.isBlockElement || parentNodeIsBlockElement,
+        };
+        return c;
+    }
+    /**
+     * Wraps text content elements with additional properties and handlers.
+     * This method iterates through an array of content elements and applies
+     * wrappers to text elements.
+     *
+     * @param node - The HTML node containing the text elements
+     **/
+    wrapChildrenTextNodes(node, elements) {
+        const wrapped = [];
+        const wrappers = [...this.handlers.wrap.values()];
+        for (const c of elements) {
+            if (!isTextCE(c)) {
+                wrapped.push(c);
+                continue;
+            }
+            this.addTextAdditionalProperties(c, node);
+            const handled = wrappers.map((wrapper) => wrapper(node, c)).find(Boolean);
+            wrapped.push(handled || c);
+        }
+        return wrapped;
+    }
+    /**
+     * Handles nested nodes by processing their children and merging text elements.
+     * This method recursively processes the children of a given HTML node and
+     * returns a list of content elements.
+     *
+     * @param node - The HTML node to process
+     **/
+    async handleNested(node) {
+        const children = await this.processChildNodes(node);
+        const filtered = children.filter(Boolean).flat();
+        const merged = this.mergeParagraphs(filtered);
+        const wrapped = this.wrapChildrenTextNodes(node, merged);
+        return wrapped;
+    }
+    async processChildNodes(node) {
+        if (this.parallelProcessing) {
+            return await Promise.all(node.childNodes.map((child) => this.process(child)));
+        }
+        const children = [];
+        for (const child of node.childNodes) {
+            children.push(await this.process(child));
+        }
+        return children;
+    }
+    /**
+     * Processes a single HTML node and converts it into content elements.
+     * This method iterates through registered node handlers and attempts to process the node.
+     * If a handler successfully processes the node, it returns an array of content elements.
+     *
+     * @param node - The HTML node to process
+     * @returns Promise resolving to an array of content elements, or undefined if node cannot be processed
+     */
+    async process(node) {
+        let isKnownNode = false;
+        const elements = [];
+        for (const [name, handler] of this.handlers.node.entries()) {
+            try {
+                const result = await handler(node);
+                if (result) {
+                    // if handler returns an array of elements, it means that the node was handled properly, even if there is no elements inside
+                    isKnownNode = true;
+                    elements.push(...result);
+                    break;
+                }
+            }
+            catch (error) {
+                this.warn({ node: node.toString(), error: error.toString(), name }, 'HandlerError');
+            }
+        }
+        if (isKnownNode)
+            return elements;
+        this.warn({ node: node.toString() }, 'UnknownNodeError');
+    }
+    /**
+     * Merges adjacent text content elements into a single paragraph.
+     * This method iterates through an array of content elements and combines
+     * adjacent text elements into a single paragraph.
+     *
+     * @param items - The array of content elements to merge
+     **/
+    mergeParagraphs(items) {
+        const merged = [];
+        let toMerge = [];
+        const merge = () => {
+            if (!toMerge.length)
+                return;
+            const paragraph = toMerge.reduce((acc, p) => {
+                return {
+                    ...p,
+                    content: acc.content + p.content,
+                };
+            }, { type: 'text', content: '' });
+            merged.push(paragraph);
+            toMerge = [];
+        };
+        for (let i = 0; i < items.length; i++) {
+            const item = items[i];
+            const isBlockElement = item.additional_properties?.isBlockElement;
+            if (isTextCE(item) && !isBlockElement) {
+                toMerge.push(item);
+            }
+            else {
+                merge();
+                merged.push(item);
+            }
+        }
+        merge();
+        return merged;
+    }
+    handleComment(_) {
+        return [];
+    }
+    async handleTable(node) {
+        return [ContentElement.raw_html(node.toString())];
+    }
+    async handleIframe(node) {
+        return [ContentElement.raw_html(node.toString())];
+    }
+    async handleImage(node) {
+        return [ContentElement.raw_html(node.toString())];
+    }
+    async handleBreak(_) {
+        return [ContentElement.divider()];
+    }
+    async createQuote(node) {
+        const items = await this.handleNested(node);
+        return [ContentElement.quote(items)];
+    }
+    async createText(node) {
+        const text = ContentElement.text(node.text);
+        return [text];
+    }
+    filterListItems(items) {
+        return items.filter((i) => ['text', 'list'].includes(i.type));
+    }
+    async createList(node, type) {
+        const items = await this.handleNested(node);
+        return [ContentElement.list(type, this.filterListItems(items))];
+    }
+    async createHeader(node) {
+        const level = +node.tagName.split('H')[1] || 3;
+        return [ContentElement.header(node.innerText, level)];
+    }
+    isBlockElement(node) {
+        if (!isHTMLElement(node))
+            return false;
+        const defaultBlockElements = new Set(BLOCK_ELEMENT_TAGS);
+        return defaultBlockElements.has(node.tagName);
+    }
+    warn(metadata, message) {
+        console.warn(metadata, message);
+    }
+}
+
+var index$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    Constants: html_constants,
+    HTMLProcessor: HTMLProcessor,
+    Utils: html_utils
+});
+
+var index = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    ContentElement: ContentElement,
+    HTML: index$1
+});
+
+exports.AnsMapper = index$2;
+exports.ArcAPI = ArcAPI;
+exports.ArcError = ArcError;
+exports.ArcTypes = index$3;
+exports.ArcUtils = ArcUtils;
+exports.ContentElements = index;
+exports.WsClient = WsClient;
+exports.default = ArcAPI;
+//# sourceMappingURL=index.cjs.map