Skip to main content
Contents

Implementation · PostgreSQL

Persian (Jalali) calendar in PostgreSQL

Dependency-free PostgreSQL implementation of the Jalali (Persian, Solar Hijri) calendar: leap years, date validation, Gregorian and Julian Day conversion, weekday and day of year. Verified day by day for 1178–3000 AP. MIT license.

Requires
PostgreSQL
Tested with
PostgreSQL 17 (PGlite)
Cross-checked against
ICU4C (Intl) and Temporal, every day
Language-specific checks
search_path injection safety, empty search_path (pg_dump), indexes, NULL, ±infinity
License
MIT
Version
1.0.0

Quick start

  1. Copy or download the source file into your project (no dependencies).

  2. Optionally, run its tests. The .zip keeps the folder layout they expect; from the language folder:

    implementations/sql
    npm install && npm test
  3. Call the shared API: function reference

Source

postgresql.sql

· 213 lines
Download
-- Copyright (C) 2026 Goudarz Jafari <hi@goudarzjafari.com>
-- SPDX-License-Identifier: MIT

-- Solar Hijri (Persian, Jalali, Shamsi) calendar for PostgreSQL.
--
-- Algorithm: 33-year arithmetic rule + 78-year correction table,
-- the same algorithm as ICU 77.1+ and ICU4X. Matches the astronomical calendar (52.5 E meridian)
-- for 1178-3000 AP. Months are 1-based; weekdays 0 = Saturday ... 6 = Friday.
--
-- Store dates as `date`/`timestamptz` and convert with these functions when you query or display.
-- All functions are IMMUTABLE, so you can use them in indexes and generated columns.
--
-- Accepted range: years -100000..100000 (JDN -34576287..38472562). Outside it, and for invalid
-- dates, the functions raise an error (SQLSTATE 22008); persian_is_valid returns false.
--
-- SQL functions use SQL-standard bodies (BEGIN ATOMIC), which bind the objects they use when they
-- are created: they do not depend on search_path at call time (safe against search_path hijacking,
-- and indexes on them survive pg_dump/restore). The PL/pgSQL functions pin search_path instead.
--
-- Functions whose body is a CASE are not declared STRICT (PostgreSQL would then refuse to inline
-- them); they return NULL for NULL arguments explicitly instead.
--
-- Requires PostgreSQL 14+. Tested with PostgreSQL 17.

CREATE TYPE persian_date AS (year integer, month integer, day integer);

-- Floor division for b > 0; PostgreSQL's integer / truncates toward zero.
CREATE OR REPLACE FUNCTION persian_fdiv(a bigint, b bigint) RETURNS bigint
LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
BEGIN ATOMIC
  SELECT (a - (((a % b) + b) % b)) / b;
END;

-- Years the 33-year rule calls leap but are not; the next year is leap instead.
CREATE OR REPLACE FUNCTION persian_is_correction(y integer) RETURNS boolean
LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
BEGIN ATOMIC
  SELECT y = ANY ('{1502,1601,1634,1667,1700,1733,1766,1799,1832,1865,1898,1931,1964,1997,2030,
    2059,2063,2096,2129,2158,2162,2191,2195,2224,2228,2257,2261,2290,2294,2323,2327,2356,2360,2389,
    2393,2422,2426,2455,2459,2488,2492,2521,2525,2554,2558,2587,2591,2620,2624,2653,2657,2686,2690,
    2719,2723,2748,2752,2756,2781,2785,2789,2818,2822,2847,2851,2855,2880,2884,2888,2913,2917,2921,
    2946,2950,2954,2979,2983,2987}'::integer[]);
END;

-- Raises the out-of-range error; called only on the error path.
CREATE OR REPLACE FUNCTION persian_year_out_of_range(y integer) RETURNS boolean
LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
SET search_path FROM CURRENT
AS $$
BEGIN
  RAISE EXCEPTION 'year out of range [-100000, 100000]: %', y USING ERRCODE = '22008';
END
$$;

-- Leap-year rule without the range check (internal).
CREATE OR REPLACE FUNCTION persian_leap_rule(y integer) RETURNS boolean
LANGUAGE sql IMMUTABLE PARALLEL SAFE
BEGIN ATOMIC
  SELECT CASE
    WHEN persian_is_correction(y) THEN false
    WHEN persian_is_correction(y - 1) THEN true
    ELSE (((25 * y::bigint + 11) % 33) + 33) % 33 < 8
  END;
END;

CREATE OR REPLACE FUNCTION persian_is_leap_year(y integer) RETURNS boolean
LANGUAGE sql IMMUTABLE PARALLEL SAFE
BEGIN ATOMIC
  SELECT CASE
    WHEN y IS NULL THEN NULL
    WHEN y < -100000 OR y > 100000 THEN persian_year_out_of_range(y)
    ELSE persian_leap_rule(y)
  END;
END;

-- 29, 30 or 31 (NULL for a month outside 1..12).
CREATE OR REPLACE FUNCTION persian_days_in_month(y integer, m integer) RETURNS integer
LANGUAGE sql IMMUTABLE PARALLEL SAFE
BEGIN ATOMIC
  SELECT CASE
    WHEN y IS NULL OR m IS NULL THEN NULL
    WHEN m < 1 OR m > 12 THEN NULL
    WHEN m <= 6 THEN 31
    WHEN m <= 11 THEN 30
    WHEN persian_is_leap_year(y) THEN 30
    ELSE 29
  END;
END;

-- True for a real Persian date in the accepted range; never raises.
CREATE OR REPLACE FUNCTION persian_is_valid(y integer, m integer, d integer) RETURNS boolean
LANGUAGE sql IMMUTABLE PARALLEL SAFE
BEGIN ATOMIC
  SELECT CASE
    WHEN y IS NULL OR m IS NULL OR d IS NULL THEN NULL
    WHEN y < -100000 OR y > 100000 OR m < 1 OR m > 12 OR d < 1 THEN false
    WHEN m <= 6 THEN d <= 31
    WHEN m <= 11 THEN d <= 30
    ELSE d <= CASE WHEN persian_leap_rule(y) THEN 30 ELSE 29 END
  END;
END;

-- Julian Day Number of 1 Farvardin (internal: the caller checks the year).
CREATE OR REPLACE FUNCTION persian_nowruz_jdn(y integer) RETURNS bigint
LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
BEGIN ATOMIC
  SELECT 1948320 + 365 * (y::bigint - 1) + persian_fdiv(8 * y::bigint + 21, 33)
         - persian_is_correction(y - 1)::integer;
END;

-- Raises the invalid-date error; called only on the error path.
CREATE OR REPLACE FUNCTION persian_invalid_date(y integer, m integer, d integer) RETURNS bigint
LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
SET search_path FROM CURRENT
AS $$
BEGIN
  RAISE EXCEPTION 'invalid Persian date: %/%/%', y, m, d USING ERRCODE = '22008';
END
$$;

CREATE OR REPLACE FUNCTION persian_to_jdn(y integer, m integer, d integer) RETURNS bigint
LANGUAGE sql IMMUTABLE PARALLEL SAFE
BEGIN ATOMIC
  SELECT CASE
    WHEN y IS NULL OR m IS NULL OR d IS NULL THEN NULL
    WHEN NOT persian_is_valid(y, m, d) THEN persian_invalid_date(y, m, d)
    ELSE persian_nowruz_jdn(y)
         + CASE WHEN m <= 7 THEN 31 * (m - 1) ELSE 30 * (m - 1) + 6 END
         + d - 1
  END;
END;

CREATE OR REPLACE FUNCTION persian_from_jdn(jdn bigint) RETURNS persian_date
LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
SET search_path FROM CURRENT
AS $$
DECLARE
  y integer;
  doy integer;
BEGIN
  IF jdn < -34576287 OR jdn > 38472562 THEN
    RAISE EXCEPTION 'jdn out of range [-34576287, 38472562]: %', jdn USING ERRCODE = '22008';
  END IF;
  y := 1 + persian_fdiv(33 * (jdn - 1948320) + 3, 12053);  -- estimate, then correct
  WHILE jdn >= persian_nowruz_jdn(y + 1) LOOP y := y + 1; END LOOP;
  WHILE jdn < persian_nowruz_jdn(y) LOOP y := y - 1; END LOOP;
  doy := jdn - persian_nowruz_jdn(y);  -- 0-based
  IF doy < 186 THEN
    RETURN ROW(y, doy / 31 + 1, doy % 31 + 1)::persian_date;
  END IF;
  doy := doy - 186;
  RETURN ROW(y, doy / 30 + 7, doy % 30 + 1)::persian_date;
END
$$;

-- date <-> Persian. JDN of 2000-01-01 is 2451545. Infinite dates raise an error.
CREATE OR REPLACE FUNCTION persian_from_date(g date) RETURNS persian_date
LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
BEGIN ATOMIC
  SELECT persian_from_jdn((g - DATE '2000-01-01') + 2451545);
END;

CREATE OR REPLACE FUNCTION persian_to_date(y integer, m integer, d integer) RETURNS date
LANGUAGE sql IMMUTABLE PARALLEL SAFE
BEGIN ATOMIC
  SELECT DATE '2000-01-01' + (persian_to_jdn(y, m, d) - 2451545)::integer;
END;

-- 0 = Saturday (شنبه) ... 6 = Friday (جمعه)
CREATE OR REPLACE FUNCTION persian_day_of_week(g date) RETURNS integer
LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
BEGIN ATOMIC
  SELECT (extract(dow FROM g)::integer + 1) % 7;
END;

-- 1 ... 365/366 (NULL for an invalid date).
CREATE OR REPLACE FUNCTION persian_day_of_year(y integer, m integer, d integer) RETURNS integer
LANGUAGE sql IMMUTABLE PARALLEL SAFE
BEGIN ATOMIC
  SELECT CASE WHEN persian_is_valid(y, m, d)
    THEN CASE WHEN m <= 7 THEN 31 * (m - 1) ELSE 30 * (m - 1) + 6 END + d
  END;
END;

-- '1404/01/01' style text, sortable for years 0..9999. Years are never truncated
-- ('10000/01/01'), and negative years keep their sign ('-0005/01/01').
-- For a timestamptz, convert to the user's zone first:
--   persian_format((created_at AT TIME ZONE 'Asia/Tehran')::date)
CREATE OR REPLACE FUNCTION persian_format(g date) RETURNS text
LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
SET search_path FROM CURRENT
AS $$
DECLARE
  p persian_date := persian_from_date(g);
  y text := abs(p.year)::text;
BEGIN
  RETURN CASE WHEN p.year < 0 THEN '-' ELSE '' END || lpad(y, greatest(4, length(y)), '0')
         || '/' || lpad(p.month::text, 2, '0') || '/' || lpad(p.day::text, 2, '0');
END
$$;

-- NULL for a month outside 1..12. lang 'fa' (default) or anything else for English.
CREATE OR REPLACE FUNCTION persian_month_name(m integer, lang text DEFAULT 'fa') RETURNS text
LANGUAGE sql IMMUTABLE PARALLEL SAFE
BEGIN ATOMIC
  SELECT CASE
    WHEN m IS NULL OR lang IS NULL THEN NULL
    ELSE CASE lang
    WHEN 'fa' THEN (ARRAY['فروردین','اردیبهشت','خرداد','تیر','مرداد','شهریور','مهر','آبان','آذر','دی','بهمن','اسفند'])[m]
    ELSE (ARRAY['Farvardin','Ordibehesht','Khordad','Tir','Mordad','Shahrivar','Mehr','Aban','Azar','Dey','Bahman','Esfand'])[m]
    END
  END;
END;

Tests

test-postgresql.mjs

135 lines
JavaScriptDownload
// Copyright (C) 2026 Goudarz Jafari <hi@goudarzjafari.com>
// SPDX-License-Identifier: MIT

// Tests postgresql.sql on a real PostgreSQL engine (PGlite = PostgreSQL compiled to WASM).
// Run: cd implementations/sql && npm install && npm test
import { PGlite } from '@electric-sql/pglite'
import { readFileSync } from 'node:fs'

const db = new PGlite()
await db.exec(readFileSync(new URL('./postgresql.sql', import.meta.url), 'utf8'))
const dataUrl = (name) => new URL(`../../data/${name}`, import.meta.url)

let checks = 0
const check = (ok, ctx) => { checks++; if (!ok) { console.error('failed:', ctx); process.exit(1) } }

// Load the ground truth into tables and compare everything in SQL.
await db.exec(`CREATE TABLE years (year int, is_leap int, days int, nowruz date, jdn bigint, weekday int);
               CREATE TABLE vectors (jy int, jm int, jd int, gy int, gm int, gd int, jdn bigint, weekday int);`)
const load = async (table, name) => {
  const lines = readFileSync(dataUrl(name), 'utf8').trim().split('\n').slice(1)
  for (let i = 0; i < lines.length; i += 1000) {
    const values = lines.slice(i, i + 1000).map((l) => '(' + l.split(',').map((v) => v.includes('-') ? `'${v}'` : v).join(',') + ')')
    await db.exec(`INSERT INTO ${table} VALUES ${values.join(',')}`)
  }
  return lines.length
}
check(await load('years', 'years.csv') === 1823, 'years loaded')
check(await load('vectors', 'test-vectors.csv') > 8000, 'vectors loaded')

const bad = async (sql) => (await db.query(sql)).rows
const noRows = async (sql, ctx) => { const rows = await bad(sql); check(rows.length === 0, `${ctx}: ${JSON.stringify(rows.slice(0, 3))}`) }

await noRows(`SELECT year FROM years WHERE persian_is_leap_year(year) <> (is_leap = 1)
              OR persian_days_in_month(year, 12) <> 29 + is_leap
              OR persian_to_date(year, 1, 1) <> nowruz OR persian_to_jdn(year, 1, 1) <> jdn
              OR persian_day_of_week(nowruz) <> weekday`, 'years')
// Every day of every year 1178-3000 against the ground truth, both directions.
await noRows(`SELECT y.year, doy FROM years y, generate_series(0, y.days - 1) AS doy,
              LATERAL (SELECT CASE WHEN doy < 186 THEN doy / 31 + 1 ELSE (doy - 186) / 30 + 7 END AS m,
                              CASE WHEN doy < 186 THEN doy % 31 + 1 ELSE (doy - 186) % 30 + 1 END AS d) md
              WHERE persian_from_jdn(y.jdn + doy) <> ROW(y.year, md.m, md.d)::persian_date
                 OR persian_to_jdn(y.year, md.m, md.d) <> y.jdn + doy`, 'every day 1178-3000')
await noRows(`SELECT * FROM vectors v, LATERAL (SELECT persian_from_date(make_date(gy, gm, gd)) AS p) x
              WHERE persian_to_date(jy, jm, jd) <> make_date(gy, gm, gd)
                 OR (x.p).year <> jy OR (x.p).month <> jm OR (x.p).day <> jd
                 OR persian_to_jdn(jy, jm, jd) <> jdn
                 OR persian_from_jdn(jdn) <> ROW(jy, jm, jd)::persian_date
                 OR persian_day_of_week(make_date(gy, gm, gd)) <> weekday`, 'vectors')
// Extrapolated years: years <= 0 make intermediate values negative (floor division matters).
const x = (await db.query(`SELECT persian_to_jdn(-1000, 1, 1) AS a, persian_to_jdn(0, 1, 1) AS b, persian_to_jdn(4000, 1, 1) AS c,
  persian_from_jdn(0) = ROW(-5334, 9, 3)::persian_date AS d, persian_is_leap_year(-3) AND NOT persian_is_leap_year(-1000) AS e`)).rows[0]
check(Number(x.a) === 1582713 && Number(x.b) === 1947955 && Number(x.c) === 3408925 && x.d && x.e, JSON.stringify(x))
// Every day of -1000..1177 and 3001..4000 round-trips and is consecutive (the day before, by lag, is the previous date).
for (const [a, b] of [[-1000, 1177], [3001, 4000]]) {
  await noRows(`WITH d AS (SELECT j, persian_from_jdn(j) AS p FROM generate_series(persian_to_jdn(${a}, 1, 1) - 1,
                  persian_to_jdn(${b}, 12, persian_days_in_month(${b}, 12))) AS j),
                l AS (SELECT j, p, lag(p) OVER (ORDER BY j) AS q FROM d)
                SELECT j FROM l WHERE q IS NOT NULL AND (
                  persian_to_jdn((p).year, (p).month, (p).day) <> j
                  OR NOT ((p).day = (q).day + 1 AND (p).month = (q).month AND (p).year = (q).year
                       OR (p).day = 1 AND ((p).month = (q).month + 1 AND (p).year = (q).year
                                        OR (p).month = 1 AND (q).month = 12 AND (p).year = (q).year + 1)))`,
               `extrapolated ${a}..${b}`)
}
// Every day of 1300..1600 round-trips and is consecutive.
await noRows(`WITH d AS (SELECT g::date AS g, persian_from_date(g::date) AS p FROM generate_series(DATE '1921-03-21', DATE '2222-03-21', '1 day') AS g)
              SELECT g FROM d WHERE persian_to_date((p).year, (p).month, (p).day) <> g`, 'round trip')
const r = (await db.query(`SELECT persian_format(DATE '2025-03-21') AS a, persian_format(DATE '2025-03-20') AS b,
  persian_is_valid(1403,12,30) AS c, persian_is_valid(1404,12,30) AS d, persian_is_valid(1404,13,1) AS e,
  persian_month_name(1) AS f, persian_day_of_year(1404, 7, 1) AS h, persian_day_of_year(1403, 12, 30) AS i, persian_day_of_year(1404, 12, 30) AS k, persian_format((TIMESTAMPTZ '2025-03-20 21:00Z' AT TIME ZONE 'Asia/Tehran')::date) AS g`)).rows[0]
check(r.a === '1404/01/01' && r.b === '1403/12/30' && r.c === true && r.d === false && r.e === false && r.f === 'فروردین' && r.h === 187 && r.i === 366 && r.k === null && r.g === '1404/01/01', JSON.stringify(r))
const k = (await db.query(`SELECT persian_from_date(DATE '1979-02-11') = ROW(1357, 11, 22)::persian_date AS a,
  persian_to_date(1304, 1, 1) = DATE '1925-03-21' AS b`)).rows[0]
check(k.a && k.b, `known dates: ${JSON.stringify(k)}`)
let threw = false
try { await db.query('SELECT persian_to_jdn(1404, 12, 30)') } catch { threw = true }
check(threw, 'invalid date raises')

// Limits: exact boundaries; everything outside raises 22008 (no bigint overflow, no hang).
const raises = async (sql) => { try { await db.query(sql); return false } catch (e) { return e.code === '22008' } }
const l = (await db.query(`SELECT persian_to_jdn(-100000, 1, 1) AS a, persian_to_jdn(100000, 12, 29) AS b,
  persian_from_jdn(-34576287) = ROW(-100000, 1, 1)::persian_date AS c, persian_from_jdn(38472562) = ROW(100000, 12, 29)::persian_date AS d,
  NOT persian_is_valid(100001, 1, 1) AND NOT persian_is_valid(-2147483648, 1, 1) AS e`)).rows[0]
check(Number(l.a) === -34576287 && Number(l.b) === 38472562 && l.c && l.d && l.e, JSON.stringify(l))
for (const sql of ['persian_from_jdn(-34576288)', 'persian_from_jdn(38472563)', 'persian_from_jdn(9223372036854775807)',
  'persian_from_jdn(-9223372036854775808)', 'persian_to_jdn(100001, 1, 1)', 'persian_to_jdn(2147483647, 1, 1)',
  'persian_is_leap_year(2147483647)', 'persian_is_leap_year(-2147483648)', 'persian_from_date(DATE \'5874897-12-31\')']) {
  check(await raises(`SELECT ${sql}`), sql)
}
let infinite = false
try { await db.query(`SELECT persian_from_date('infinity'::date)`) } catch { infinite = true }
check(infinite, 'infinite date raises')
// persian_format never truncates and keeps the sign (lpad alone would give '1000' and '00-5').
const f = (await db.query(`SELECT persian_format(persian_to_date(10000, 1, 1)) AS a, persian_format(persian_to_date(-5, 1, 1)) AS b,
  persian_format(persian_to_date(5, 1, 1)) AS c, persian_format(DATE '4714-11-24 BC') AS d`)).rows[0]
check(f.a === '10000/01/01' && f.b === '-0005/01/01' && f.c === '0005/01/01' && f.d === '-5334/09/03', JSON.stringify(f))
// The functions do not depend on search_path at call time: shadowing helpers or an empty
// search_path (as pg_dump uses while restoring indexes) changes nothing.
await db.exec(`CREATE SCHEMA evil;
  CREATE FUNCTION evil.persian_is_correction(y integer) RETURNS boolean LANGUAGE sql AS 'SELECT true';
  CREATE FUNCTION evil.persian_fdiv(a bigint, b bigint) RETURNS bigint LANGUAGE sql AS 'SELECT 0::bigint';
  CREATE TABLE events (id int, at date);
  INSERT INTO events SELECT i, DATE '2025-03-21' + i FROM generate_series(0, 999) i;
  CREATE INDEX events_persian ON events (persian_format(at));`)
await db.exec(`SET search_path = evil, public`)
const s = (await db.query(`SELECT public.persian_format(DATE '2025-03-21') AS a, public.persian_is_leap_year(1404) AS b,
  public.persian_to_jdn(1404, 1, 1) AS c, (public.persian_from_jdn(2460756)).year AS d`)).rows[0]
check(s.a === '1404/01/01' && s.b === false && Number(s.c) === 2460756 && s.d === 1404, `search_path hijack: ${JSON.stringify(s)}`)
await db.exec(`SET search_path = ''`)
const e = (await db.query(`SELECT public.persian_format(DATE '2025-03-21') AS a, count(*)::int AS n FROM public.events
  WHERE public.persian_format(at) LIKE '1404/01/%'`)).rows[0]
check(e.a === '1404/01/01' && e.n === 31, `empty search_path: ${JSON.stringify(e)}`)
await db.exec(`REINDEX TABLE public.events; SET search_path = "$user", public`)
// NULL in, NULL out (also for the functions that are not STRICT so they can be inlined).
const n = (await db.query(`SELECT persian_is_leap_year(NULL) IS NULL AND persian_days_in_month(1404, NULL) IS NULL
  AND persian_is_valid(NULL, 0, 1) IS NULL AND persian_to_jdn(1404, NULL, 1) IS NULL AND persian_to_date(NULL, 1, 1) IS NULL
  AND persian_day_of_year(1404, 1, NULL) IS NULL AND persian_month_name(NULL) IS NULL AND persian_month_name(1, NULL) IS NULL
  AND persian_from_jdn(NULL) IS NULL AND persian_from_date(NULL) IS NULL AND persian_format(NULL) IS NULL AS ok`)).rows[0]
check(n.ok, 'NULL handling')

// Every year -100000..100000: years are contiguous, first and last day round-trip, and the leap years
// sit where every other implementation (and ICU 77.1+) puts them (checksums).
const full = (await db.query(`
  WITH t AS (SELECT y, persian_to_jdn(y, 1, 1) AS nowruz, persian_is_leap_year(y)::int AS leap
             FROM generate_series(-100000, 100000) AS y),
       y AS (SELECT *, lead(nowruz, 1, 38472563::bigint) OVER (ORDER BY y) AS next_nowruz FROM t)
  SELECT count(*) FILTER (WHERE nowruz + 365 + leap <> next_nowruz) AS gaps,
         count(*) FILTER (WHERE persian_from_jdn(nowruz) <> ROW(y, 1, 1)::persian_date
                             OR persian_from_jdn(nowruz + 364 + leap) <> ROW(y, 12, 29 + leap)::persian_date
                             OR persian_days_in_month(y, 12) <> 29 + leap) AS wrong,
         min(nowruz) AS first, sum(leap)::int AS leaps, sum(nowruz)::text AS nowruz_sum
  FROM y`)).rows[0]
check(full.gaps === 0 && full.wrong === 0 && Number(full.first) === -34576287 && full.leaps === 48485 &&
  full.nowruz_sum === '389592978180', `full range: ${JSON.stringify(full)}`)
console.log(`OK: ${checks} checks passed`)

Project files

package.json

18 lines
JSONDownload
{
  "name": "persian-calendar-sql",
  "private": true,
  "author": "Goudarz Jafari <hi@goudarzjafari.com>",
  "type": "module",
  "license": "MIT",
  "repository": {
    "type": "git",
    "url": "git+https://github.com/Goudarz/PersianCalendar.git",
    "directory": "implementations/sql"
  },
  "scripts": {
    "test": "node test-postgresql.mjs"
  },
  "devDependencies": {
    "@electric-sql/pglite": "^0.3.0"
  }
}

Other languages