octoparse-cli 0.1.14

package/node_modules/@octopus/engine/dist/models/operation.js

@@ -0,0 +1,242 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Operation = void 0;
+const utils_1 = require("../utils");
+const DateTimeFormatHelper_1 = __importDefault(require("../utils/DateTimeFormatHelper"));
+const moment_1 = __importDefault(require("moment"));
+class Operation {
+    constructor() {
+        this.index = 0;
+        this.name = '';
+        this.input = '';
+        this.output = '';
+    }
+    regexTra(v) {
+        let traObj = {
+            '\\\\': '\\\\',
+            '\\)': '\\)',
+            '\\(': '\\(',
+            '\\*': '\\*',
+            '\\.': '\\.',
+            '\\?': '\\?',
+            '\\+': '\\+',
+            '\\$': '\\$',
+            '\\^': '\\^',
+            '\\[': '\\[',
+            '\\]': '\\]',
+            '\\{': '\\{',
+            '\\}': '\\}',
+            '\\|': '\\|',
+            '\\/': '\\/'
+        };
+        let r = v;
+        for (let k in traObj) {
+            let reg = new RegExp(k, 'g');
+            r = r.replace(reg, traObj[k]);
+        }
+        return r;
+    }
+    /** 把v7版本里面的\b替换为等价的式子 */
+    transPatternForV7(pattern) {
+        const p = /\\b/g;
+        const transp = '((?<![^a-zA-Z0-9_\\u4e00-\\u9fa5])(?=[^a-zA-Z0-9_\\u4e00-\\u9fa5])|(?<=[^a-zA-Z0-9_\\u4e00-\\u9fa5])(?![^a-zA-Z0-9_\\u4e00-\\u9fa5])|$)';
+        let patternNew = pattern.replace(p, transp);
+        return patternNew;
+    }
+    htmlDecode(source) {
+        if (source.length == 0)
+            return '';
+        let s = '';
+        s = source.replace(/&amp;/g, '&');
+        s = s.replace(/&lt;/g, '<');
+        s = s.replace(/&gt;/g, '>');
+        s = s.replace(/&nbsp;/g, ' ');
+        s = s.replace(/&#39;/g, "'");
+        s = s.replace(/&quot;/g, '"');
+        return s;
+    }
+    async caculate(input) {
+        this.input = input;
+        switch (this.formatType) {
+            case "Replace" /* FormatType.Replace */:
+                {
+                    const regex = new RegExp(this.regexTra(this.parameters[0]), 'g');
+                    this.output = this.input.replace(regex, this.parameters[1]);
+                }
+                break;
+            case "RegReplace" /* FormatType.RegReplace */:
+                {
+                    const pattern = this.transPatternForV7(this.parameters[0]);
+                    const regexMatch = pattern.match(/^\/(.+)\/([gimyus]*)$/);
+                    let regex;
+                    if (regexMatch) {
+                        const pattern_new = regexMatch[1];
+                        const flags_new = regexMatch[2];
+                        regex = new RegExp(pattern_new, flags_new);
+                    }
+                    else {
+                        regex = new RegExp(pattern, 'g');
+                    }
+                    /**
+                     * 在 Worker 线程中执行正则替换，防止某些耗时正则表达式卡死 UI 线程
+                     * PS：这里未设置执行超时时间，默认是 10s，如果觉得等待太久可以传入超时时间
+                     * 使用 encodeURI/decodeURI 来转义字符串，这样字符串含有换行符等特殊字符能正常传递
+                     * 这里暂时未做错误提示，用户会不知道正则替换失败，看是否需要提示
+                     */
+                    const str = encodeURI(this.input);
+                    const replaceValue = encodeURI(this.parameters[1]);
+                    const code = `decodeURI("${str}").replace(${regex}, decodeURI("${replaceValue}"))`;
+                    const result = await (0, utils_1.executeJavaScriptInWorker)(code).catch((error) => console.error(error));
+                    this.output = typeof result === 'string' ? result : this.input;
+                }
+                break;
+            case "RegMatch" /* FormatType.RegMatch */:
+                {
+                    const isMatchAll = this.parameters[1].toLowerCase() === 'true';
+                    const pattern = this.transPatternForV7(this.parameters[0]);
+                    const regexMatch = pattern.match(/^\/(.+)\/([gimyus]*)$/);
+                    let basePattern = pattern;
+                    let flags = '';
+                    if (regexMatch) {
+                        basePattern = regexMatch[1];
+                        flags = regexMatch[2];
+                    }
+                    else {
+                        flags = isMatchAll ? 'gm' : '';
+                    }
+                    const regex = new RegExp(basePattern, flags);
+                    // 情况1：显式需要全局（勾选“匹配所有”或用户正则带 g）→ 整体匹配并合并
+                    if (isMatchAll || flags.includes('g')) {
+                        const str = encodeURI(this.input);
+                        const code = `decodeURI("${str}").match(${regex})`;
+                        const result = await (0, utils_1.executeJavaScriptInWorker)(code).catch((error) => console.error(error));
+                        this.output = result
+                            ? Array.isArray(result)
+                                ? result.join('\r\n')
+                                : String(result)
+                            : '';
+                    }
+                    else {
+                        // 情况2：默认（不勾选“匹配所有”，且正则不含 g）→ 按行取每行的第一个命中
+                        const normalized = this.input.replace(/@\/n/g, '\n');
+                        const lines = normalized.split(/\r?\n/);
+                        const matches = [];
+                        for (const line of lines) {
+                            const m = line.match(regex);
+                            if (m && m[0] !== undefined) {
+                                matches.push(m[0]);
+                            }
+                        }
+                        this.output = matches.join('\r\n');
+                    }
+                }
+                break;
+            case "AddPrefix" /* FormatType.AddPrefix */:
+                {
+                    this.output = this.parameters[0] + this.input;
+                }
+                break;
+            case "AddSuffix" /* FormatType.AddSuffix */:
+                {
+                    this.output = this.input + this.parameters[0];
+                }
+                break;
+            case "Trim" /* FormatType.Trim */:
+                {
+                    let trimType = parseInt(this.parameters[0]);
+                    switch (trimType) {
+                        case 0 /* TrimType.TrimBoth */:
+                            this.output = this.input.trim();
+                            break;
+                        case 1 /* TrimType.TrimStart */:
+                            this.output = this.input.trimLeft();
+                            break;
+                        case 2 /* TrimType.TrimEnd */:
+                            this.output = this.input.trimRight();
+                            break;
+                        default:
+                            break;
+                    }
+                }
+                break;
+            case "FormatDateTime" /* FormatType.FormatDateTime */:
+                {
+                    // 去除首尾全部空格
+                    const input = this.input.trim();
+                    // 先匹配特殊时间字符串转换为时间对象
+                    let date = (0, utils_1.transformDate)(input);
+                    if (!date) {
+                        date = new Date(DateTimeFormatHelper_1.default.formatChinese(input));
+                    }
+                    /**  兼容荷兰语的3月，5月, 10月无法生效的问题 (BZY-15444)  */
+                    if (isNaN(date.getTime())) {
+                        const mon = input.toLocaleLowerCase();
+                        if (mon.includes('maart')) {
+                            date = new Date(input.replace(/maart/gi, 'Mar'));
+                        }
+                        if (mon.includes('mei')) {
+                            date = new Date(input.replace(/mei/gi, 'May'));
+                        }
+                        if (mon.includes('oktober')) {
+                            date = new Date(input.replace(/oktober/gi, 'Oct'));
+                        }
+                    }
+                    if (!isNaN(date.getTime())) {
+                        this.output = DateTimeFormatHelper_1.default.format(date, this.parameters[0]);
+                    }
+                    else {
+                        this.output = this.input;
+                    }
+                }
+                break;
+            case "FormatTimestamp" /* FormatType.FormatTimestamp */:
+                {
+                    const timestampType = Number(this.parameters[0]);
+                    switch (timestampType) {
+                        case 0 /* TimestampType.TimestampToDateTime */:
+                            {
+                                const input = this.input.trim();
+                                /** 判断字符串是否是纯数字组成，有其它字符则不格式化 */
+                                const isNumber = /^\d+$/.test(input);
+                                if (!isNumber) {
+                                    this.output = this.input;
+                                    break;
+                                }
+                                const time = parseInt(input);
+                                let date = input.length === 13 ? (0, moment_1.default)(time) : moment_1.default.unix(time);
+                                if (date.isValid())
+                                    this.output = date.format('YYYY-MM-DD HH:mm:ss');
+                                else
+                                    this.output = this.input;
+                            }
+                            break;
+                        case 1 /* TimestampType.DateTimeToTimestamp */:
+                            {
+                                const date = (0, moment_1.default)(this.input.trim());
+                                if (date.isValid())
+                                    this.output = date.unix().toString();
+                                else
+                                    this.output = this.input;
+                            }
+                            break;
+                    }
+                }
+                break;
+            case "FormatTimeZone" /* FormatType.FormatTimeZone */:
+                this.output = DateTimeFormatHelper_1.default.timeZone(this.input, this.parameters[0]);
+                break;
+            case "HtmlDecode" /* FormatType.HtmlDecode */:
+                {
+                    this.output = this.htmlDecode(this.input);
+                }
+                break;
+            default:
+                break;
+        }
+        return this.output;
+    }
+}
+exports.Operation = Operation;

package/node_modules/@octopus/engine/dist/models/retryCondition.d.ts

@@ -0,0 +1,7 @@
+import { RetryConditionType } from '../enums';
+export declare class RetryCondition {
+    mainValue: string;
+    containsOrNot: boolean;
+    minorValue?: string;
+    conditionType: RetryConditionType;
+}

package/node_modules/@octopus/engine/dist/models/retryCondition.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryCondition = void 0;
+class RetryCondition {
+    constructor() {
+        this.mainValue = '';
+        this.containsOrNot = false;
+    }
+}
+exports.RetryCondition = RetryCondition;

package/node_modules/@octopus/engine/dist/models/task.d.ts

@@ -0,0 +1,89 @@
+import { TaskType } from '../enums';
+export declare class WorkflowSetting {
+    /** 是否在任务设置界面显示自动跳过无效的循环点击选项 */
+    showJumpInvalidClickSetting: boolean;
+    /** 多少次后开始判断无效循环点击 */
+    repeatPageLoopCount: number;
+    /** 连续判断多少次循环点击才选无效 */
+    continuousJudgeCount: number;
+}
+export declare class CookiesRule {
+    /** 需要排除在顶级域名设置 Cookies 的域名列表 */
+    excludeSetTopDomainList: Array<string>;
+}
+export declare enum IpProxyFromType {
+    /** 不使用代理 IP */
+    None = 0,
+    /** 收费优质代理 IP */
+    Strong = 1,
+    /** 自定义代理 IP */
+    Custom = 2,
+    /** 伪造 IP */
+    Fake = 3
+}
+export declare enum UserAgentSwitchType {
+    /** 不切换 UA */
+    None = 0,
+    /** 自定义切换周期 */
+    Custom = 1,
+    /** 切换代理 IP 时切换 */
+    FollowIP = 2
+}
+export declare enum CookieClearType {
+    /** 不清除 Cookies */
+    None = 0,
+    /** 自定义清除周期 */
+    Custom = 1,
+    /** 切换代理 IP 时清除 */
+    FollowIP = 2
+}
+export declare class BrokerSettings {
+    ipProxySettings: {
+        ipProxyFromType: IpProxyFromType;
+        strongIpProxySettings: {
+            period: number;
+        };
+        customIpProxySettings: {
+            switchPeriod: number;
+            proxies: any[];
+        };
+    };
+    userAgentSwitchSettings: {
+        switchType: UserAgentSwitchType;
+        customPeriod: number;
+        userAgents: any[];
+    };
+    cookieClearSettings: {
+        clearType: CookieClearType;
+        customPeriod: number;
+    };
+}
+export declare class Task {
+    /** 任务 ID */
+    taskID: string;
+    /** 任务名 */
+    taskName: string;
+    /** 任务类型 */
+    taskType: TaskType;
+    /** 任务流程原始文档 */
+    xml: string;
+    /** 任务适配 bpmn 格式的文档 */
+    xoml: string;
+    /** 屏蔽广告 */
+    disableAD: boolean;
+    /** 禁用图片加载 */
+    disableImage: boolean;
+    /** 浏览器使用的 UA，未设定则使用默认 UA */
+    userAgent: string;
+    /** 工作流服务端保存的全局配置 */
+    workflowSetting: WorkflowSetting;
+    /** Cookies 设置规则 */
+    cookiesRule: CookiesRule;
+    /** 防封设置 */
+    brokerSettings: BrokerSettings;
+    update({ taskId, taskName, workFlowType, adBlockEnable, disableImage, userAgent, brokerSettings }: any): void;
+}
+export declare class SubTask extends Task {
+    /** 子任务 ID */
+    subTaskID: string;
+}

package/node_modules/@octopus/engine/dist/models/task.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubTask = exports.Task = exports.BrokerSettings = exports.CookieClearType = exports.UserAgentSwitchType = exports.IpProxyFromType = exports.CookiesRule = exports.WorkflowSetting = void 0;
+const enums_1 = require("../enums");
+const lodash_1 = require("lodash");
+class WorkflowSetting {
+    constructor() {
+        /** 是否在任务设置界面显示自动跳过无效的循环点击选项 */
+        this.showJumpInvalidClickSetting = true;
+        /** 多少次后开始判断无效循环点击 */
+        this.repeatPageLoopCount = 50;
+        /** 连续判断多少次循环点击才选无效 */
+        this.continuousJudgeCount = 5;
+    }
+}
+exports.WorkflowSetting = WorkflowSetting;
+class CookiesRule {
+    constructor() {
+        /** 需要排除在顶级域名设置 Cookies 的域名列表 */
+        this.excludeSetTopDomainList = [];
+    }
+}
+exports.CookiesRule = CookiesRule;
+var IpProxyFromType;
+(function (IpProxyFromType) {
+    /** 不使用代理 IP */
+    IpProxyFromType[IpProxyFromType["None"] = 0] = "None";
+    /** 收费优质代理 IP */
+    IpProxyFromType[IpProxyFromType["Strong"] = 1] = "Strong";
+    /** 自定义代理 IP */
+    IpProxyFromType[IpProxyFromType["Custom"] = 2] = "Custom";
+    /** 伪造 IP */
+    IpProxyFromType[IpProxyFromType["Fake"] = 3] = "Fake";
+})(IpProxyFromType || (exports.IpProxyFromType = IpProxyFromType = {}));
+var UserAgentSwitchType;
+(function (UserAgentSwitchType) {
+    /** 不切换 UA */
+    UserAgentSwitchType[UserAgentSwitchType["None"] = 0] = "None";
+    /** 自定义切换周期 */
+    UserAgentSwitchType[UserAgentSwitchType["Custom"] = 1] = "Custom";
+    /** 切换代理 IP 时切换 */
+    UserAgentSwitchType[UserAgentSwitchType["FollowIP"] = 2] = "FollowIP";
+})(UserAgentSwitchType || (exports.UserAgentSwitchType = UserAgentSwitchType = {}));
+var CookieClearType;
+(function (CookieClearType) {
+    /** 不清除 Cookies */
+    CookieClearType[CookieClearType["None"] = 0] = "None";
+    /** 自定义清除周期 */
+    CookieClearType[CookieClearType["Custom"] = 1] = "Custom";
+    /** 切换代理 IP 时清除 */
+    CookieClearType[CookieClearType["FollowIP"] = 2] = "FollowIP";
+})(CookieClearType || (exports.CookieClearType = CookieClearType = {}));
+class BrokerSettings {
+    constructor() {
+        this.ipProxySettings = {
+            ipProxyFromType: IpProxyFromType.None,
+            strongIpProxySettings: {
+                period: 0,
+            },
+            customIpProxySettings: {
+                switchPeriod: 0,
+                proxies: [],
+            },
+        };
+        this.userAgentSwitchSettings = {
+            switchType: UserAgentSwitchType.None,
+            customPeriod: 0,
+            userAgents: [],
+        };
+        this.cookieClearSettings = {
+            clearType: CookieClearType.None,
+            customPeriod: 0,
+        };
+    }
+}
+exports.BrokerSettings = BrokerSettings;
+class Task {
+    constructor() {
+        /** 任务 ID */
+        this.taskID = '';
+        /** 任务名 */
+        this.taskName = '';
+        /** 任务类型 */
+        this.taskType = enums_1.TaskType.Customize;
+        /** 任务流程原始文档 */
+        this.xml = '';
+        /** 任务适配 bpmn 格式的文档 */
+        this.xoml = '';
+        /** 屏蔽广告 */
+        this.disableAD = false;
+        /** 禁用图片加载 */
+        this.disableImage = false;
+        /** 浏览器使用的 UA，未设定则使用默认 UA */
+        this.userAgent = '';
+        /** 工作流服务端保存的全局配置 */
+        this.workflowSetting = new WorkflowSetting();
+        /** Cookies 设置规则 */
+        this.cookiesRule = new CookiesRule();
+        /** 防封设置 */
+        this.brokerSettings = new BrokerSettings();
+    }
+    update({ taskId, taskName, workFlowType, adBlockEnable, disableImage, userAgent, brokerSettings }) {
+        this.taskID = taskId;
+        this.taskName = taskName;
+        this.taskType = workFlowType;
+        this.disableAD = adBlockEnable;
+        this.disableImage = disableImage;
+        this.userAgent = userAgent;
+        (0, lodash_1.merge)(this.brokerSettings, brokerSettings);
+    }
+}
+exports.Task = Task;
+class SubTask extends Task {
+    constructor() {
+        super(...arguments);
+        /** 子任务 ID */
+        this.subTaskID = '';
+    }
+}
+exports.SubTask = SubTask;

package/node_modules/@octopus/engine/dist/models/trigger.d.ts

@@ -0,0 +1,66 @@
+import { Operation } from './operation';
+export declare class Trigger {
+    Name: string;
+    Status: number;
+    Priority: number;
+    LoopLevel: number;
+    Enabled: boolean;
+    TriggerAdditionGroups: TriggerAdditionGroup[];
+    clone(): Trigger;
+}
+export declare class TriggerAdditionGroup {
+    Id: number;
+    TriggerAdditions: TriggerAddition[];
+    clone(): TriggerAdditionGroup;
+}
+export declare class TriggerAddition {
+    Id: number;
+    OperatingSymbol: OperatingSymbol;
+    FieldName: string;
+    Content: string;
+    FormatTemplate: string;
+    DateTimeType: DateTimeType;
+    FormatDateTimeType: DateTimeType;
+    Increase: boolean;
+    Year: number;
+    Month: number;
+    Day: number;
+    Hour: number;
+    Minute: number;
+    Second: number;
+    Operations: Operation[];
+    clone(): TriggerAddition;
+}
+export declare enum OperatingSymbol {
+    StringEqual = "StringEqual",
+    StringNotEqual = "StringNotEqual",
+    StringContains = "StringContains",
+    StringNotContains = "StringNotContains",
+    StringNotEmpty = "StringNotEmpty",
+    StringEmpty = "StringEmpty",
+    IntGreaterThan = "IntGreaterThan",
+    IntLessThan = "IntLessThan",
+    IntGreaterThanOrEqual = "IntGreaterThanOrEqual",
+    IntLessThanOrEqual = "IntLessThanOrEqual",
+    DateGreaterThan = "DateGreaterThan",
+    DateLessThan = "DateLessThan",
+    DateGreaterThanOrEqual = "DateGreaterThanOrEqual",
+    DateLessThanOrEqual = "DateLessThanOrEqual"
+}
+export declare enum DateTimeType {
+    CurrentTime = "CurrentTime",
+    ZeroPoint = "ZeroPoint",
+    Custom = "Custom"
+}
+export declare enum ExtractTriggerStatus {
+    UploadExtractedData = 0,
+    NotSave = 1,
+    BreakLoop = 2,
+    EndWorkflow = 3,
+    Other = 100
+}
+export interface ExtractTriggerConfig {
+    status: ExtractTriggerStatus;
+    loopLevel: number;
+    name: string;
+}

package/node_modules/@octopus/engine/dist/models/trigger.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtractTriggerStatus = exports.DateTimeType = exports.OperatingSymbol = exports.TriggerAddition = exports.TriggerAdditionGroup = exports.Trigger = void 0;
+const operation_1 = require("./operation");
+class Trigger {
+    constructor() {
+        this.Name = '';
+        this.Status = 0;
+        this.Priority = 0;
+        this.LoopLevel = 0;
+        this.Enabled = false;
+        this.TriggerAdditionGroups = [];
+    }
+    clone() {
+        let trigger = new Trigger();
+        trigger.Name = this.Name;
+        trigger.Status = this.Status;
+        trigger.Priority = this.Priority;
+        trigger.LoopLevel = this.LoopLevel;
+        trigger.Enabled = this.Enabled;
+        trigger.TriggerAdditionGroups = this.TriggerAdditionGroups.map((g) => g.clone());
+        return trigger;
+    }
+}
+exports.Trigger = Trigger;
+class TriggerAdditionGroup {
+    constructor() {
+        this.Id = 0;
+        this.TriggerAdditions = [];
+    }
+    clone() {
+        let group = new TriggerAdditionGroup();
+        group.Id = this.Id;
+        group.TriggerAdditions = this.TriggerAdditions.map((ta) => ta.clone());
+        return group;
+    }
+}
+exports.TriggerAdditionGroup = TriggerAdditionGroup;
+class TriggerAddition {
+    constructor() {
+        this.Id = 0;
+        this.OperatingSymbol = OperatingSymbol.StringNotEmpty;
+        this.FieldName = '';
+        this.Content = '';
+        this.FormatTemplate = '';
+        this.DateTimeType = null;
+        this.FormatDateTimeType = null;
+        this.Increase = false;
+        this.Year = 0;
+        this.Month = 0;
+        this.Day = 0;
+        this.Hour = 0;
+        this.Minute = 0;
+        this.Second = 0;
+        this.Operations = [];
+    }
+    clone() {
+        let triggerAddition = new TriggerAddition();
+        triggerAddition.FieldName = this.FieldName;
+        triggerAddition.OperatingSymbol = this.OperatingSymbol;
+        triggerAddition.Content = this.Content;
+        triggerAddition.DateTimeType = this.DateTimeType;
+        triggerAddition.FormatDateTimeType = this.FormatDateTimeType;
+        triggerAddition.Increase = this.Increase;
+        triggerAddition.Year = this.Year;
+        triggerAddition.Month = this.Month;
+        triggerAddition.Day = this.Day;
+        triggerAddition.Hour = this.Hour;
+        triggerAddition.Minute = this.Minute;
+        triggerAddition.Second = this.Second;
+        triggerAddition.Id = this.Id;
+        triggerAddition.FormatTemplate = this.FormatTemplate;
+        triggerAddition.Operations = this.Operations.map((o) => {
+            let op = new operation_1.Operation();
+            op.input = o.input;
+            op.formatType = o.formatType;
+            op.index = o.index;
+            op.input = o.input;
+            op.parameters = o.parameters;
+            op.output = o.output;
+            return op;
+        });
+        return triggerAddition;
+    }
+}
+exports.TriggerAddition = TriggerAddition;
+var OperatingSymbol;
+(function (OperatingSymbol) {
+    OperatingSymbol["StringEqual"] = "StringEqual";
+    OperatingSymbol["StringNotEqual"] = "StringNotEqual";
+    OperatingSymbol["StringContains"] = "StringContains";
+    OperatingSymbol["StringNotContains"] = "StringNotContains";
+    OperatingSymbol["StringNotEmpty"] = "StringNotEmpty";
+    OperatingSymbol["StringEmpty"] = "StringEmpty";
+    OperatingSymbol["IntGreaterThan"] = "IntGreaterThan";
+    OperatingSymbol["IntLessThan"] = "IntLessThan";
+    OperatingSymbol["IntGreaterThanOrEqual"] = "IntGreaterThanOrEqual";
+    OperatingSymbol["IntLessThanOrEqual"] = "IntLessThanOrEqual";
+    OperatingSymbol["DateGreaterThan"] = "DateGreaterThan";
+    OperatingSymbol["DateLessThan"] = "DateLessThan";
+    OperatingSymbol["DateGreaterThanOrEqual"] = "DateGreaterThanOrEqual";
+    OperatingSymbol["DateLessThanOrEqual"] = "DateLessThanOrEqual";
+})(OperatingSymbol || (exports.OperatingSymbol = OperatingSymbol = {}));
+var DateTimeType;
+(function (DateTimeType) {
+    DateTimeType["CurrentTime"] = "CurrentTime";
+    DateTimeType["ZeroPoint"] = "ZeroPoint";
+    DateTimeType["Custom"] = "Custom";
+})(DateTimeType || (exports.DateTimeType = DateTimeType = {}));
+var ExtractTriggerStatus;
+(function (ExtractTriggerStatus) {
+    ExtractTriggerStatus[ExtractTriggerStatus["UploadExtractedData"] = 0] = "UploadExtractedData";
+    ExtractTriggerStatus[ExtractTriggerStatus["NotSave"] = 1] = "NotSave";
+    ExtractTriggerStatus[ExtractTriggerStatus["BreakLoop"] = 2] = "BreakLoop";
+    ExtractTriggerStatus[ExtractTriggerStatus["EndWorkflow"] = 3] = "EndWorkflow";
+    ExtractTriggerStatus[ExtractTriggerStatus["Other"] = 100] = "Other";
+})(ExtractTriggerStatus || (exports.ExtractTriggerStatus = ExtractTriggerStatus = {}));

package/node_modules/@octopus/engine/dist/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@octopus/engine",
+  "version": "1.0.21",
+  "description": "run octoparse in real browser",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "type": "commonjs",
+  "keywords": [],
+  "dependencies": {},
+  "exports": {
+    ".": "./index.js",
+    "./transformer": "./translator/translator.js",
+    "./enums": "./enums/index.js",
+    "./browser": "./browser.js",
+    "./type": "./type.js",
+    "./settings": "./settings.js"
+  },
+  "devDependencies": {
+    "@types/node": "22.9.0",
+    "@types/ws": "8.5.14",
+    "@types/xmldom": "0.1.34",
+    "glob": "11.0.3",
+    "javascript-obfuscator": "4.1.1",
+    "typescript": "catalog:"
+  }
+}