typeof window !== "undefined" ? window : this;

if (typeof define === "function" && define.amd) {
  // AMD 模式 (RequireJS)
  define(function () {
    return factory();
  });
} else if (typeof module === "object" && module.exports) {
  // CommonJS 模式 (Node.js)
  module.exports = factory();
} else {
  // 瀏覽器全局變量模式
  global.SurveyTimezone = factory();
}

function () {
    'use strict';

    // 構(gòu)造函數(shù)定義
    function SurveyTimezone(options) {
    }

    // 原型方法定義
    SurveyTimezone.prototype = {
        constructor: SurveyTimezone, // 修復(fù) constructor 指向
        version: '1.0.0',
        _init: function () {
        }
    }

    // 返回構(gòu)造函數(shù)
    return SurveyTimezone;
}

(function (global, factory) {
    // 環(huán)境檢測(cè)和模塊導(dǎo)出邏輯
}(typeof window !== "undefined" ? window : this, function () {
    // 工廠函數(shù)：創(chuàng)建并返回構(gòu)造函數(shù)
}));

// 閉包中的私有變量，存儲(chǔ)單例實(shí)例
var instance = null;

function SurveyTimezone(options) {
    // 1. 如果已存在實(shí)例，直接返回
    if (instance) {
        return instance;
    }
    
    // 2. 確保通過(guò) new 調(diào)用
    if (!(this instanceof SurveyTimezone)) {
        return new SurveyTimezone(options);
    }
    
    // 3. 初始化配置
    this.options = options || {};
    
    // 4. 保存單例實(shí)例
    instance = this;
    
    // 5. 執(zhí)行初始化
    this._init();
    
    return instance;
}

/**
 * 獲取單例實(shí)例
 */
SurveyTimezone.getInstance = function (options) {
    if (!instance) {
        instance = new SurveyTimezone(options);
    }
    return instance;
}

/**
 * 重置單例（用于測(cè)試）
 */
SurveyTimezone.resetInstance = function () {
    instance = null;
}

const instance1 = new SurveyTimezone({ timezone: 'Asia/Shanghai' });
const instance2 = new SurveyTimezone({ timezone: 'America/New_York' });

console.log(instance1 === instance2); // true（返回同一個(gè)實(shí)例）

const instance = SurveyTimezone.getInstance({ timezone: 'Asia/Shanghai' });

const instance = SurveyTimezone({ timezone: 'Asia/Shanghai' });

// 第一次創(chuàng)建實(shí)例
const timezone1 = new SurveyTimezone({ 
    timezone: 'Asia/Shanghai',
    locale: 'zh-CN'
});

// 第二次嘗試創(chuàng)建（返回第一次的實(shí)例）
const timezone2 = new SurveyTimezone({ 
    timezone: 'America/New_York'  // 這個(gè)配置會(huì)被忽略
});

console.log(timezone1 === timezone2);        // true
console.log(timezone1.options.timezone);     // 'Asia/Shanghai'

// 重置單例后可以創(chuàng)建新實(shí)例
SurveyTimezone.resetInstance();
const timezone3 = new SurveyTimezone({ 
    timezone: 'Europe/London'
});

console.log(timezone1 === timezone3);        // false
console.log(timezone3.options.timezone);     // 'Europe/London'

new SurveyTimezone(input, format)

const tz = new SurveyTimezone('2025-10-28 14:30:45');
console.log(tz.getDate());      // Date 對(duì)象
console.log(tz.format());       // '2025-10-28 14:30:45'

const tz = new SurveyTimezone(1698484245000);
console.log(tz.getDate());      // Date 對(duì)象
console.log(tz.format());       // 對(duì)應(yīng)的日期時(shí)間字符串

const tz = new SurveyTimezone('28/10/2025', 'DD/MM/YYYY');
console.log(tz.format('YYYY-MM-DD'));  // '2025-10-28'

const tz = new SurveyTimezone(new Date());
console.log(tz.format());       // 當(dāng)前時(shí)間

const tz = new SurveyTimezone({
    date: '2025-10-28 14:30:45',
    timezone: 'Asia/Shanghai',
    locale: 'zh-CN'
});
console.log(tz.getDate());      // Date 對(duì)象
console.log(tz.options);        // { date: '...', timezone: '...', locale: '...' }

const tz = new SurveyTimezone();
console.log(tz.format());       // 當(dāng)前時(shí)間

const tz = new SurveyTimezone('2025-10-28 14:30:45');
const date = tz.getDate();
console.log(date);  // Date 對(duì)象

const tz = new SurveyTimezone();

// 設(shè)置新日期
tz.setDate('2025-12-25 00:00:00');
console.log(tz.format());  // '2025-12-25 00:00:00'

// 鏈?zhǔn)秸{(diào)用
const result = tz.setDate('2026-01-01').format('YYYY/MM/DD');
console.log(result);  // '2026/01/01'

const tz = new SurveyTimezone('2025-10-28 14:30:45');

// 格式化實(shí)例日期（無(wú)參數(shù)）
tz.format();                    // '2025-10-28 14:30:45'（默認(rèn)格式）

// 格式化實(shí)例日期（指定格式）
tz.format('YYYY年MM月DD日');    // '2025年10月28日'

// 格式化指定日期
tz.format(new Date(), 'YYYY-MM-DD');  // 格式化其他日期

// 場(chǎng)景：接收用戶輸入 → 解析 → 處理 → 格式化輸出

// 1. 用戶輸入歐洲格式日期
const userInput = '28/10/2025';

// 2. 創(chuàng)建實(shí)例并解析
const tz = new SurveyTimezone(userInput, 'DD/MM/YYYY');

// 3. 驗(yàn)證解析結(jié)果
console.log(tz.getDate());  // Date 對(duì)象

// 4. 格式化為不同格式輸出
console.log(tz.format('YYYY-MM-DD'));      // '2025-10-28'（ISO格式）
console.log(tz.format('YYYY年MM月DD日'));  // '2025年10月28日'（中文）
console.log(tz.format('MMM DD, yyyy'));    // 'Oct 28, 2025'（英文）

// 5. 修改日期并重新格式化
tz.setDate('2025-12-25');
console.log(tz.format('YYYY年MM月DD日'));  // '2025年12月25日'

// 第一次創(chuàng)建，指定日期
const tz1 = new SurveyTimezone('2025-10-28 14:30:45');
console.log(tz1.format());  // '2025-10-28 14:30:45'

// 第二次創(chuàng)建，嘗試傳入不同日期（但返回的是同一個(gè)實(shí)例）
const tz2 = new SurveyTimezone('2026-01-01 00:00:00');
console.log(tz2.format());  // '2025-10-28 14:30:45'（仍然是第一次的日期）
console.log(tz1 === tz2);   // true（同一個(gè)實(shí)例）

// 如果需要新的日期，可以使用 setDate 方法
tz2.setDate('2026-01-01 00:00:00');
console.log(tz2.format());  // '2026-01-01 00:00:00'
console.log(tz1.format());  // '2026-01-01 00:00:00'（tz1 也變了，因?yàn)槭峭粋€(gè)實(shí)例）

// 或者先重置單例
SurveyTimezone.resetInstance();
const tz3 = new SurveyTimezone('2026-01-01 00:00:00');
console.log(tz3.format());  // '2026-01-01 00:00:00'（新實(shí)例，新日期）

// 無(wú)效日期字符串
const tz1 = new SurveyTimezone('invalid date');
console.log(tz1.getDate());  // 當(dāng)前時(shí)間的 Date 對(duì)象

// 重置單例
SurveyTimezone.resetInstance();

// 無(wú)效時(shí)間戳
const tz2 = new SurveyTimezone(NaN);
console.log(tz2.getDate());  // 當(dāng)前時(shí)間的 Date 對(duì)象

// 原型方法
instance.format(date, format)

// 靜態(tài)方法（向后兼容）
SurveyTimezone.format(date, format)

const tz = new SurveyTimezone();
const now = new Date('2025-10-28 14:30:45.123');

// 默認(rèn)格式
tz.format(now);  // '2025-10-28 14:30:45'

// 自定義格式
tz.format(now, 'YYYY/MM/DD');  // '2025/10/28'
tz.format(now, 'HH:mm:ss');    // '14:30:45'

const tz = new SurveyTimezone();
const now = new Date('2025-10-28 14:30:45.123');

tz.format(now, 'YYYY-MM-DD HH:mm:ss');      // '2025-10-28 14:30:45'
tz.format(now, 'YYYY-MM-DD HH:mm:ss.SSS');  // '2025-10-28 14:30:45.123'
tz.format(now, 'YY/M/D H:m:s');             // '25/10/28 14:30:45'
tz.format(now, 'MMM DD, YYYY');             // 'Oct 28, 2025'

const tz = new SurveyTimezone();
const now = new Date('2025-10-28 14:30:45');

tz.format(now, 'yyyy-MM-dd HH:mm:ss');  // '2025-10-28 14:30:45'
tz.format(now, 'yyyy年MM月dd日');        // '2025年10月28日'
tz.format(now, 'y-M-d H:m:s');          // '25-10-28 14:30:45'
tz.format(now, 'dd/MM/yyyy');           // '28/10/2025'

const tz = new SurveyTimezone();
const now = new Date('2025-10-28 14:30:45');

tz.format(now, 'YYYY年MM月DD日');               // '2025年10月28日'
tz.format(now, 'YYYY年MM月DD日 HH時(shí)mm分ss秒');   // '2025年10月28日 14時(shí)30分45秒'
tz.format(now, 'yyyy年MM月dd日 HH:mm');         // '2025年10月28日 14:30'

const now = new Date('2025-10-28 14:30:45');

// 直接使用靜態(tài)方法
SurveyTimezone.format(now, 'YYYY-MM-DD');      // '2025-10-28'
SurveyTimezone.format(now, 'yyyy年MM月dd日');  // '2025年10月28日'
SurveyTimezone.format(now, 'MMM DD, yyyy');    // 'Oct 28, 2025'

const tz = new SurveyTimezone();

// 無(wú)效日期返回空字符串
tz.format(null);                    // ''
tz.format(undefined);               // ''
tz.format(new Date('invalid'));     // ''
tz.format('2025-10-28');            // ''（字符串不是 Date 對(duì)象）

// 有效日期
tz.format(new Date());              // '2025-10-28 14:30:45'（當(dāng)前時(shí)間）

// 標(biāo)記處理順序（長(zhǎng)的在前，短的在后）
var tokens = ['YYYY', 'yyyy', 'MMM', 'SSS', 'MM', 'DD', 'dd', 'HH', 'mm', 'ss', 'YY', 'M', 'D', 'd', 'H', 'm', 's', 'y'];

// 依次替換每個(gè)標(biāo)記
for (var i = 0; i < tokens.length; i++) {
    var token = tokens[i];
    if (result.indexOf(token) !== -1) {
        result = result.replace(new RegExp(token, 'g'), matches[token]());
    }
}

// 靜態(tài)方法實(shí)現(xiàn)（調(diào)用原型方法）
SurveyTimezone.format = function (date, format) {
    return SurveyTimezone.prototype.format.call(null, date, format);
}

// 原型方法
instance.parse(dateString, format)

// 靜態(tài)方法（向后兼容）
SurveyTimezone.parse(dateString, format)

const tz = new SurveyTimezone();

// 指定格式解析
tz.parse('28-10-2025', 'DD-MM-YYYY');
tz.parse('10/28/2025', 'MM/DD/YYYY');
tz.parse('25/10/28 14:30', 'YY/MM/DD HH:mm');

const tz = new SurveyTimezone();

// 標(biāo)準(zhǔn)格式
tz.parse('2025-10-28 14:30:45');           // Date 對(duì)象
tz.parse('2025-10-28');                    // Date 對(duì)象

// 斜杠格式
tz.parse('2025/10/28 14:30:45');           // Date 對(duì)象
tz.parse('2025/10/28');                    // Date 對(duì)象

// 中文格式
tz.parse('2025年10月28日');                 // Date 對(duì)象
tz.parse('2025年10月28日 14時(shí)30分45秒');    // Date 對(duì)象

// 時(shí)間戳
tz.parse(1698484245000);                   // Date 對(duì)象

// 帶毫秒
tz.parse('2025-10-28 14:30:45.123');       // Date 對(duì)象

const tz = new SurveyTimezone();

// 歐洲日期格式（DD/MM/YYYY）
tz.parse('28/10/2025', 'DD/MM/YYYY');

// 美式日期格式（MM/DD/YYYY）
tz.parse('10/28/2025', 'MM/DD/YYYY');

// 短年份格式
tz.parse('25/10/28', 'YY/MM/DD');          // 2025-10-28

// 自定義格式
tz.parse('28-10-2025 14:30', 'DD-MM-YYYY HH:mm');

const tz = new SurveyTimezone();

// 無(wú)效輸入返回 null
tz.parse(null);                            // null
tz.parse(undefined);                       // null
tz.parse('');                              // null
tz.parse('invalid date');                  // null
tz.parse('2025-13-40');                    // null（無(wú)效日期）

// 類型檢查
const result = tz.parse('2025-10-28');
if (result) {
    console.log('解析成功:', result);
} else {
    console.log('解析失敗');
}

// 直接使用靜態(tài)方法，無(wú)需實(shí)例化
const date1 = SurveyTimezone.parse('2025-10-28');
const date2 = SurveyTimezone.parse('2025/10/28');
const date3 = SurveyTimezone.parse('2025年10月28日');
const date4 = SurveyTimezone.parse('28-10-2025', 'DD-MM-YYYY');

const tz = new SurveyTimezone();

// 解析后格式化輸出
const parsedDate = tz.parse('2025-10-28 14:30:45');
if (parsedDate) {
    console.log(tz.format(parsedDate, 'YYYY年MM月DD日'));        // '2025年10月28日'
    console.log(tz.format(parsedDate, 'MMM DD, yyyy'));         // 'Oct 28, 2025'
    console.log(tz.format(parsedDate, 'HH:mm:ss'));             // '14:30:45'
}

// 格式轉(zhuǎn)換
const input = '28/10/2025';
const date = tz.parse(input, 'DD/MM/YYYY');
const output = tz.format(date, 'YYYY-MM-DD');
console.log(output);  // '2025-10-28'

輸入值
  ↓
┌─────────────────────────────────┐
│ 1. 類型檢查                      │
│    - null/undefined → null       │
│    - Date 對(duì)象 → 驗(yàn)證后返回      │
│    - 數(shù)字 → 時(shí)間戳解析           │
└─────────────────────────────────┘
  ↓
┌─────────────────────────────────┐
│ 2. 格式化參數(shù)檢查                │
│    - 有 format → 使用格式模板解析 │
│    - 無(wú) format → 自動(dòng)識(shí)別         │
└─────────────────────────────────┘
  ↓
┌─────────────────────────────────┐
│ 3. 原生解析嘗試                  │
│    - new Date(dateString)        │
│    - 成功 → 返回                 │
│    - 失敗 → 繼續(xù)                 │
└─────────────────────────────────┘
  ↓
┌─────────────────────────────────┐
│ 4. 正則匹配解析                  │
│    - 遍歷預(yù)定義格式列表          │
│    - 匹配成功 → 返回             │
│    - 全部失敗 → 返回 null        │
└─────────────────────────────────┘

const tz = new SurveyTimezone();

// 用戶輸入的日期字符串
const userInput = document.getElementById('dateInput').value;  // '2025-10-28'
const date = tz.parse(userInput);

if (date) {
    // 轉(zhuǎn)換為顯示格式
    const displayText = tz.format(date, 'YYYY年MM月DD日');
    console.log(displayText);  // '2025年10月28日'
}

const tz = new SurveyTimezone();

// API 返回的日期字符串
const apiData = {
    createdAt: '2025-10-28T14:30:45.123Z',
    updatedAt: '2025/10/28 14:30:45'
};

// 解析并格式化
const createdDate = tz.parse(apiData.createdAt);
const updatedDate = tz.parse(apiData.updatedAt);

console.log(tz.format(createdDate, 'YYYY-MM-DD HH:mm:ss'));
console.log(tz.format(updatedDate, 'YYYY-MM-DD HH:mm:ss'));

const tz = new SurveyTimezone();

// 不同格式的日期數(shù)組
const dates = [
    '2025-10-28',
    '2025/10/28',
    '2025年10月28日',
    '28/10/2025'  // 需要指定格式
];

// 統(tǒng)一轉(zhuǎn)換為標(biāo)準(zhǔn)格式
const normalized = dates.map((dateStr, index) => {
    const format = index === 3 ? 'DD/MM/YYYY' : undefined;
    const date = tz.parse(dateStr, format);
    return date ? tz.format(date, 'YYYY-MM-DD') : null;
});

console.log(normalized);  // ['2025-10-28', '2025-10-28', '2025-10-28', '2025-10-28']

const tz = new SurveyTimezone();

// ? 不推薦：每次都自動(dòng)識(shí)別
for (let i = 0; i < 1000; i++) {
    tz.parse('28/10/2025');
}

// ? 推薦：指定格式
for (let i = 0; i < 1000; i++) {
    tz.parse('28/10/2025', 'DD/MM/YYYY');
}

const tz = new SurveyTimezone();

// 數(shù)據(jù)輸入 → 處理 → 輸出
const input = '28/10/2025';                          // 用戶輸入
const date = tz.parse(input, 'DD/MM/YYYY');          // 解析為 Date 對(duì)象
const output = tz.format(date, 'YYYY年MM月DD日');    // 格式化為顯示文本

console.log(output);  // '2025年10月28日'

// 靜態(tài)方法實(shí)現(xiàn)（調(diào)用原型方法）
SurveyTimezone.parse = function (dateString, format) {
    // 使用原型對(duì)象作為上下文，以便訪問(wèn)內(nèi)部方法
    return SurveyTimezone.prototype.parse.call(SurveyTimezone.prototype, dateString, format);
}

/**
 * SurveyTimezone - 時(shí)間處理插件
 * @description 專門用于處理調(diào)查問(wèn)卷中的時(shí)區(qū)轉(zhuǎn)換和顯示問(wèn)題
 * @version 1.0.0
 * @author wjxcom
 */

(function (global, factory) {
    // UMD模式支持 - 兼容AMD、CommonJS和全局變量
    if (typeof define === 'function' && define.amd) {
        // AMD模式
        define(function () { return factory(); });
    } else if (typeof module === 'object' && module.exports) {
        // CommonJS模式
        module.exports = factory();
    } else {
        // 瀏覽器全局變量模式
        global.SurveyTimezone = factory();
    }
}(typeof window !== 'undefined' ? window : this, function () {
    'use strict';
    
    /**
     * 單例實(shí)例存儲(chǔ)
     * @private
     */
    var instance = null;
    
    /**
     * 時(shí)區(qū)數(shù)據(jù)映射表（用于快速查找）
     * @private
     */
    var timezoneDataMap = {};


    /**
     * SurveyTimezone 主類（單例模式）
     * @param {string|number|Date|Object} input - 日期時(shí)間字符串、時(shí)間戳、Date對(duì)象或配置對(duì)象
     * @param {string} format - 可選的日期格式（當(dāng) input 為字符串時(shí)使用）
     * @returns {SurveyTimezone} 單例實(shí)例
     * @description 采用單例模式，多次實(shí)例化返回同一個(gè)對(duì)象
     * @example
     *   new SurveyTimezone('2025-10-28 14:30:45');
     *   new SurveyTimezone(1698484245000);
     *   new SurveyTimezone('28/10/2025', 'DD/MM/YYYY');
     *   new SurveyTimezone({ date: '2025-10-28', timezone: 'Asia/Shanghai' });
     */
    function SurveyTimezone(input, format) {
        // 單例模式：如果已存在實(shí)例，直接返回
        if (instance) {
            return instance;
        }
        
        // 確保通過(guò) new 調(diào)用
        if (!(this instanceof SurveyTimezone)) {
            return new SurveyTimezone(input, format);
        }
        
        // 解析輸入?yún)?shù)
        this._parseInput(input, format);
        
        // 保存單例實(shí)例
        instance = this;
        
        // 執(zhí)行初始化
        this._init();
        
        return instance;
    }

    SurveyTimezone.prototype = {
        constructor: SurveyTimezone,
        version: '1.0.0',
        
        /**
         * 解析輸入?yún)?shù)
         * @private
         * @param {string|number|Date|Object} input - 輸入?yún)?shù)
         * @param {string} format - 日期格式
         */
        _parseInput: function (input, format) {
            // 初始化配置對(duì)象
            this.options = {};
            this.date = null;
            
            // 如果沒(méi)有輸入，使用當(dāng)前時(shí)間
            if (input === undefined || input === null) {
                this.date = new Date();
                return;
            }
            
            // 如果是配置對(duì)象
            if (typeof input === 'object' && !(input instanceof Date)) {
                this.options = input;
                // 從配置中提取日期
                if (input.date !== undefined) {
                    this.date = this.parse(input.date, input.format || format);
                } else {
                    this.date = new Date();
                }
                return;
            }
            
            // 其他情況：字符串、數(shù)字、Date 對(duì)象
            this.date = this.parse(input, format);
            
            // 如果解析失敗，使用當(dāng)前時(shí)間
            if (!this.date) {
                this.date = new Date();
            }
        },
        
        /**
         * 初始化方法
         * @private
         */
        _init: function () {
            // 初始化邏輯
            // 可以在這里添加時(shí)區(qū)處理、本地化等邏輯
        },
        
        /**
         * 獲取當(dāng)前實(shí)例的日期對(duì)象
         * @returns {Date} 日期對(duì)象
         */
        getDate: function () {
            return this.date;
        },
        
        /**
         * 設(shè)置日期
         * @param {string|number|Date} dateInput - 日期時(shí)間字符串、時(shí)間戳或Date對(duì)象
         * @param {string} format - 可選的日期格式
         * @returns {SurveyTimezone} 返回當(dāng)前實(shí)例（鏈?zhǔn)秸{(diào)用）
         */
        setDate: function (dateInput, format) {
            this.date = this.parse(dateInput, format);
            if (!this.date) {
                this.date = new Date();
            }
            return this;
        },
        
        /**
         * 格式化日期 - 兼容 dayjs 和 laydate 的格式化方式（原型方法）
         * @param {Date|string} date - 要格式化的日期對(duì)象（可選，默認(rèn)使用實(shí)例日期）
         * @param {string} format - 格式化模板字符串（默認(rèn)：'YYYY-MM-DD HH:mm:ss'）
         * @returns {string} 格式化后的日期字符串
         * @description 支持的格式化標(biāo)記：
         *   年份：
         *     YYYY/yyyy - 四位年份（2025）
         *     YY/y      - 兩位年份（25）
         *   月份：
         *     MMM  - 英文月份縮寫（Jan, Feb, Mar...）
         *     MM   - 兩位月份（01-12）
         *     M    - 月份（1-12）
         *   日期：
         *     DD/dd - 兩位日期（01-31）
         *     D/d   - 日期（1-31）
         *   時(shí)間：
         *     HH - 24小時(shí)制小時(shí)（00-23）
         *     H  - 24小時(shí)制小時(shí)（0-23）
         *     mm - 分鐘（00-59）
         *     m  - 分鐘（0-59）
         *     ss - 秒（00-59）
         *     s  - 秒（0-59）
         *   毫秒：
         *     SSS - 毫秒（000-999）
         * @example
         *   const tz = new SurveyTimezone('2025-10-28 14:30:45');
         *   tz.format();                                // '2025-10-28 14:30:45'（使用實(shí)例日期）
         *   tz.format('YYYY年MM月DD日');                // '2025年10月28日'（使用實(shí)例日期）
         *   tz.format(new Date(), 'YYYY-MM-DD');        // 格式化指定日期
         */
        format: function (date, format) {
            // 如果第一個(gè)參數(shù)是字符串，說(shuō)明是格式參數(shù)
            if (typeof date === 'string' && !format) {
                format = date;
                date = this.date;
            }
            
            // 如果沒(méi)有傳入 date，使用實(shí)例的日期
            if (!date || typeof date === 'string') {
                date = this.date;
            }
            
            // 默認(rèn)格式
            format = format || 'YYYY-MM-DD HH:mm:ss';
            
            // 驗(yàn)證日期對(duì)象
            if (!date || !(date instanceof Date) || isNaN(date.getTime())) {
                return '';
            }
            
            // 月份英文縮寫
            var monthNames = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 
                              'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
            
            // 定義格式化標(biāo)記映射
            var matches = {
                // 年份（支持 dayjs 和 laydate 格式）
                'YYYY': function() { return date.getFullYear(); },
                'yyyy': function() { return date.getFullYear(); },
                'YY': function() { return String(date.getFullYear()).slice(-2); },
                'y': function() { return String(date.getFullYear()).slice(-2); },
                // 月份
                'MMM': function() { return monthNames[date.getMonth()]; },
                'MM': function() { return ('0' + (date.getMonth() + 1)).slice(-2); },
                'M': function() { return date.getMonth() + 1; },
                // 日期（支持 dayjs 和 laydate 格式）
                'DD': function() { return ('0' + date.getDate()).slice(-2); },
                'dd': function() { return ('0' + date.getDate()).slice(-2); },
                'D': function() { return date.getDate(); },
                'd': function() { return date.getDate(); },
                // 時(shí)間
                'HH': function() { return ('0' + date.getHours()).slice(-2); },
                'H': function() { return date.getHours(); },
                'mm': function() { return ('0' + date.getMinutes()).slice(-2); },
                'm': function() { return date.getMinutes(); },
                'ss': function() { return ('0' + date.getSeconds()).slice(-2); },
                's': function() { return date.getSeconds(); },
                // 毫秒
                'SSS': function() { return ('00' + date.getMilliseconds()).slice(-3); }
            };
            
            // 按標(biāo)記長(zhǎng)度從長(zhǎng)到短排序，先處理長(zhǎng)標(biāo)記避免沖突
            // 注意：MMM 要在 MM 之前處理，yyyy 要在 y 之前處理
            var tokens = ['YYYY', 'yyyy', 'MMM', 'SSS', 'MM', 'DD', 'dd', 'HH', 'mm', 'ss', 'YY', 'M', 'D', 'd', 'H', 'm', 's', 'y'];
            
            var result = format;
            for (var i = 0; i < tokens.length; i++) {
                var token = tokens[i];
                if (result.indexOf(token) !== -1) {
                    result = result.replace(new RegExp(token, 'g'), matches[token]());
                }
            }
            
            return result;
        },
        
        /**
         * 解析日期時(shí)間字符串（原型方法）
         * @param {string|number} dateString - 日期時(shí)間字符串或時(shí)間戳
         * @param {string} format - 可選的格式模板，用于指定解析格式
         * @returns {Date|null} 解析后的 Date 對(duì)象，解析失敗返回 null
         * @description 支持多種常見(jiàn)日期格式的自動(dòng)識(shí)別和解析
         * @example
         *   const tz = new SurveyTimezone();
         *   tz.parse('2025-10-28 14:30:45');        // Date 對(duì)象
         *   tz.parse('2025/10/28');                 // Date 對(duì)象
         *   tz.parse('2025年10月28日');             // Date 對(duì)象
         *   tz.parse(1698484245000);                // Date 對(duì)象（時(shí)間戳）
         *   tz.parse('invalid');                    // null
         */
        parse: function (dateString, format) {
            // 處理 null 或 undefined
            if (dateString == null) {
                return null;
            }
            
            // 如果已經(jīng)是 Date 對(duì)象，直接返回
            if (dateString instanceof Date) {
                return isNaN(dateString.getTime()) ? null : dateString;
            }
            
            // 處理數(shù)字類型（時(shí)間戳）
            if (typeof dateString === 'number') {
                var date = new Date(dateString);
                return isNaN(date.getTime()) ? null : date;
            }
            
            // 轉(zhuǎn)換為字符串
            dateString = String(dateString).trim();
            
            if (!dateString) {
                return null;
            }
            
            // 如果指定了格式模板，使用格式模板解析
            if (format) {
                return this._parseWithFormat(dateString, format);
            }
            
            // 嘗試使用原生 Date 解析
            var nativeDate = new Date(dateString);
            if (!isNaN(nativeDate.getTime())) {
                return nativeDate;
            }
            
            // 嘗試常見(jiàn)格式的正則匹配
            var patterns = [
                // YYYY-MM-DD HH:mm:ss.SSS
                {
                    regex: /^(\d{4})-(\d{1,2})-(\d{1,2})\s+(\d{1,2}):(\d{1,2}):(\d{1,2})\.(\d{1,3})$/,
                    handler: function(m) {
                        return new Date(m[1], m[2] - 1, m[3], m[4], m[5], m[6], m[7]);
                    }
                },
                // YYYY-MM-DD HH:mm:ss
                {
                    regex: /^(\d{4})-(\d{1,2})-(\d{1,2})\s+(\d{1,2}):(\d{1,2}):(\d{1,2})$/,
                    handler: function(m) {
                        return new Date(m[1], m[2] - 1, m[3], m[4], m[5], m[6]);
                    }
                },
                // YYYY-MM-DD HH:mm
                {
                    regex: /^(\d{4})-(\d{1,2})-(\d{1,2})\s+(\d{1,2}):(\d{1,2})$/,
                    handler: function(m) {
                        return new Date(m[1], m[2] - 1, m[3], m[4], m[5]);
                    }
                },
                // YYYY-MM-DD
                {
                    regex: /^(\d{4})-(\d{1,2})-(\d{1,2})$/,
                    handler: function(m) {
                        return new Date(m[1], m[2] - 1, m[3]);
                    }
                },
                // YYYY/MM/DD HH:mm:ss
                {
                    regex: /^(\d{4})\/(\d{1,2})\/(\d{1,2})\s+(\d{1,2}):(\d{1,2}):(\d{1,2})$/,
                    handler: function(m) {
                        return new Date(m[1], m[2] - 1, m[3], m[4], m[5], m[6]);
                    }
                },
                // YYYY/MM/DD
                {
                    regex: /^(\d{4})\/(\d{1,2})\/(\d{1,2})$/,
                    handler: function(m) {
                        return new Date(m[1], m[2] - 1, m[3]);
                    }
                },
                // YYYY年MM月DD日 HH時(shí)mm分ss秒
                {
                    regex: /^(\d{4})年(\d{1,2})月(\d{1,2})日\(chéng)s*(\d{1,2})時(shí)(\d{1,2})分(\d{1,2})秒$/,
                    handler: function(m) {
                        return new Date(m[1], m[2] - 1, m[3], m[4], m[5], m[6]);
                    }
                },
                // YYYY年MM月DD日
                {
                    regex: /^(\d{4})年(\d{1,2})月(\d{1,2})日$/,
                    handler: function(m) {
                        return new Date(m[1], m[2] - 1, m[3]);
                    }
                },
                // DD/MM/YYYY
                {
                    regex: /^(\d{1,2})\/(\d{1,2})\/(\d{4})$/,
                    handler: function(m) {
                        return new Date(m[3], m[2] - 1, m[1]);
                    }
                },
                // MM/DD/YYYY (美式格式)
                {
                    regex: /^(\d{1,2})-(\d{1,2})-(\d{4})$/,
                    handler: function(m) {
                        return new Date(m[3], m[1] - 1, m[2]);
                    }
                }
            ];
            
            // 嘗試匹配各種格式
            for (var i = 0; i < patterns.length; i++) {
                var match = dateString.match(patterns[i].regex);
                if (match) {
                    var parsedDate = patterns[i].handler(match);
                    if (!isNaN(parsedDate.getTime())) {
                        return parsedDate;
                    }
                }
            }
            
            // 解析失敗
            return null;
        },
        
        /**
         * 使用指定格式解析日期字符串（內(nèi)部方法）
         * @private
         * @param {string} dateString - 日期字符串
         * @param {string} format - 格式模板
         * @returns {Date|null} 解析后的 Date 對(duì)象
         */
        _parseWithFormat: function (dateString, format) {
            // 構(gòu)建正則表達(dá)式，將格式標(biāo)記替換為捕獲組
            var formatRegex = format
                .replace(/YYYY|yyyy/g, '(\\d{4})')
                .replace(/YY|yy/g, '(\\d{2})')
                .replace(/MM/g, '(\\d{1,2})')
                .replace(/DD|dd/g, '(\\d{1,2})')
                .replace(/HH/g, '(\\d{1,2})')
                .replace(/mm/g, '(\\d{1,2})')
                .replace(/ss/g, '(\\d{1,2})')
                .replace(/SSS/g, '(\\d{1,3})');
            
            var regex = new RegExp('^' + formatRegex + '$');
            var match = dateString.match(regex);
            
            if (!match) {
                return null;
            }
            
            // 提取各個(gè)部分
            var tokens = format.match(/YYYY|yyyy|YY|yy|MM|DD|dd|HH|mm|ss|SSS/g) || [];
            var values = {
                year: 0,
                month: 0,
                day: 1,
                hour: 0,
                minute: 0,
                second: 0,
                millisecond: 0
            };
            
            for (var i = 0; i < tokens.length; i++) {
                var token = tokens[i];
                var value = parseInt(match[i + 1], 10);
                
                if (token === 'YYYY' || token === 'yyyy') {
                    values.year = value;
                } else if (token === 'YY' || token === 'yy') {
                    values.year = value < 50 ? 2000 + value : 1900 + value;
                } else if (token === 'MM') {
                    values.month = value - 1;
                } else if (token === 'DD' || token === 'dd') {
                    values.day = value;
                } else if (token === 'HH') {
                    values.hour = value;
                } else if (token === 'mm') {
                    values.minute = value;
                } else if (token === 'ss') {
                    values.second = value;
                } else if (token === 'SSS') {
                    values.millisecond = value;
                }
            }
            
            var date = new Date(
                values.year,
                values.month,
                values.day,
                values.hour,
                values.minute,
                values.second,
                values.millisecond
            );
            
            return isNaN(date.getTime()) ? null : date;
        }
    }
    
    /**
     * 獲取單例實(shí)例（靜態(tài)方法）
     * @param {Object} options - 配置選項(xiàng)
     * @returns {SurveyTimezone} 單例實(shí)例
     */
    SurveyTimezone.getInstance = function (options) {
        if (!instance) {
            instance = new SurveyTimezone(options);
        }
        return instance;
    }
    
    /**
     * 重置單例實(shí)例（用于測(cè)試或重新初始化）
     * @static
     */
    SurveyTimezone.resetInstance = function () {
        instance = null;
    }

    // ==================== 靜態(tài)方法 ====================
    /**
     * 格式化日期 - 靜態(tài)方法（向后兼容）
     * @static
     * @param {Date} date - 要格式化的日期對(duì)象
     * @param {string} format - 格式化模板字符串
     * @returns {string} 格式化后的日期字符串
     * @description 靜態(tài)方法，可直接調(diào)用而無(wú)需實(shí)例化
     * @example
     *   SurveyTimezone.format(new Date(), 'YYYY-MM-DD');
     */
    SurveyTimezone.format = function (date, format) {
        // 調(diào)用原型方法實(shí)現(xiàn)
        return SurveyTimezone.prototype.format.call(null, date, format);
    }
    
    /**
     * 解析日期時(shí)間字符串 - 靜態(tài)方法（向后兼容）
     * @static
     * @param {string|number} dateString - 日期時(shí)間字符串或時(shí)間戳
     * @param {string} format - 可選的格式模板
     * @returns {Date|null} 解析后的 Date 對(duì)象，解析失敗返回 null
     * @description 靜態(tài)方法，可直接調(diào)用而無(wú)需實(shí)例化
     * @example
     *   SurveyTimezone.parse('2025-10-28 14:30:45');
     *   SurveyTimezone.parse('2025/10/28');
     *   SurveyTimezone.parse('28/10/2025', 'DD/MM/YYYY');
     */
    SurveyTimezone.parse = function (dateString, format) {
        // 使用原型對(duì)象作為上下文調(diào)用原型方法
        return SurveyTimezone.prototype.parse.call(SurveyTimezone.prototype, dateString, format);
    }


    // 返回構(gòu)造函數(shù)
    return SurveyTimezone;

}))

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script src="index.js"></script>
</head>
<body>
    <script>
        console.log('=== 初始化測(cè)試 - 傳入日期時(shí)間 ===');
        
        // 重置單例以便測(cè)試
        SurveyTimezone.resetInstance();
        
        // 方式1: 傳入日期字符串
        const tz1 = new SurveyTimezone('2025-10-28 14:30:45');
        console.log('字符串初始化:', tz1.getDate());
        console.log('格式化輸出:', tz1.format());
        console.log('自定義格式:', tz1.format('YYYY年MM月DD日 HH時(shí)mm分'));
        
        // 重置單例
        SurveyTimezone.resetInstance();
        
        // 方式2: 傳入時(shí)間戳
        const tz2 = new SurveyTimezone(1698484245000);
        console.log('\n時(shí)間戳初始化:', tz2.getDate());
        console.log('格式化輸出:', tz2.format());
        
        // 重置單例
        SurveyTimezone.resetInstance();
        
        // 方式3: 傳入日期字符串和格式
        const tz3 = new SurveyTimezone('28/10/2025', 'DD/MM/YYYY');
        console.log('\n指定格式初始化:', tz3.getDate());
        console.log('格式化輸出:', tz3.format('YYYY-MM-DD'));
        
        // 重置單例
        SurveyTimezone.resetInstance();
        
        // 方式4: 傳入配置對(duì)象
        const tz4 = new SurveyTimezone({ 
            date: '2025-10-28 14:30:45',
            timezone: 'Asia/Shanghai' 
        });
        console.log('\n配置對(duì)象初始化:', tz4.getDate());
        console.log('格式化輸出:', tz4.format());
        console.log('配置信息:', tz4.options);
        
        // 重置單例
        SurveyTimezone.resetInstance();
        
        // 方式5: 不傳參數(shù)（使用當(dāng)前時(shí)間）
        const tz5 = new SurveyTimezone();
        console.log('\n默認(rèn)初始化（當(dāng)前時(shí)間）:', tz5.getDate());
        console.log('格式化輸出:', tz5.format());
        
        console.log('\n=== setDate 方法測(cè)試 ===');
        
        // 修改日期
        tz5.setDate('2025-12-25 00:00:00');
        console.log('修改后的日期:', tz5.getDate());
        console.log('格式化輸出:', tz5.format('YYYY年MM月DD日'));
        
        // 鏈?zhǔn)秸{(diào)用
        console.log('鏈?zhǔn)秸{(diào)用:', tz5.setDate('2026-01-01').format('YYYY/MM/DD'));
        
        console.log('\n=== 單例模式驗(yàn)證 ===');
        
        // 驗(yàn)證單例
        const instance1 = tz5;
        const instance2 = new SurveyTimezone('2025-10-28');
        console.log('單例驗(yàn)證:', instance1 === instance2 ? '? 通過(guò)（返回同一實(shí)例）' : '? 失敗');
        
        console.log('\n=== 格式化方法測(cè)試 ===');
        
        // 格式化實(shí)例日期
        SurveyTimezone.resetInstance();
        const tzFormat = new SurveyTimezone('2025-10-28 14:30:45');
        console.log('格式化實(shí)例日期（無(wú)參）:', tzFormat.format());
        console.log('格式化實(shí)例日期（指定格式）:', tzFormat.format('YYYY年MM月DD日'));
        console.log('格式化實(shí)例日期（英文）:', tzFormat.format('MMM DD, yyyy'));
        
        // 格式化指定日期
        const now = new Date();
        console.log('格式化指定日期:', tzFormat.format(now, 'YYYY-MM-DD HH:mm:ss'));
        
        console.log('\n=== 格式化方法測(cè)試 - 靜態(tài)方法（向后兼容）===');
        console.log('靜態(tài)方法 - 完整格式:', SurveyTimezone.format(now, 'YYYY-MM-DD HH:mm:ss'));
        console.log('靜態(tài)方法 - laydate格式:', SurveyTimezone.format(now, 'yyyy-MM-dd HH:mm:ss'));
        console.log('靜態(tài)方法 - 英文月份:', SurveyTimezone.format(now, 'MMM DD, yyyy'));
        console.log('靜態(tài)方法 - 自定義格式:', SurveyTimezone.format(now, 'YYYY年MM月DD日 HH時(shí)mm分ss秒'));
        
        console.log('\n=== parse 方法測(cè)試（靜態(tài)方法）===');
        
        // 測(cè)試靜態(tài)方法 - 自動(dòng)識(shí)別格式
        console.log('parse標(biāo)準(zhǔn)格式:', SurveyTimezone.parse('2025-10-28 14:30:45'));
        console.log('parse中文格式:', SurveyTimezone.parse('2025年10月28日'));
        console.log('parse時(shí)間戳:', SurveyTimezone.parse(1698484245000));
        
        // 測(cè)試靜態(tài)方法 - 指定格式（這個(gè)會(huì)觸發(fā) _parseWithFormat）
        console.log('parse指定格式1:', SurveyTimezone.parse('28/10/2025', 'DD/MM/YYYY'));
        console.log('parse指定格式2:', SurveyTimezone.parse('2025年10月28日', 'YYYY年MM月DD日'));
        console.log('parse指定格式3:', SurveyTimezone.parse('25-10-28', 'YY-MM-DD'));
        
        console.log('\n=== 完整工作流測(cè)試 ===');
        
        // 場(chǎng)景：用戶輸入 → 解析 → 處理 → 格式化輸出
        SurveyTimezone.resetInstance();
        const workflow = new SurveyTimezone('28/10/2025', 'DD/MM/YYYY');
        console.log('輸入:', '28/10/2025');
        console.log('解析:', workflow.getDate());
        console.log('輸出1:', workflow.format('YYYY-MM-DD'));
        console.log('輸出2:', workflow.format('YYYY年MM月DD日'));
        console.log('輸出3:', workflow.format('MMM DD, yyyy'));
    </script>
</body>
</html>