DEV Community: Indian Modassir

PGI - Payment Getaway Integration

Indian Modassir — Sun, 19 Oct 2025 07:00:47 +0000

PGI is a PHP library that provides ready-to-use integrations for multiple payment gateways.

Composer Installation

Installation is super-easy via Composer

composer require lazervel/pgi

OR:

Click to Browse package

Payment Integrations

Razorpay Integration

Razorpay Integration

Start accepting domestic and international payments from customers on your website using the Razorpay Payment Gateway. Razorpay has developed the Standard Checkout method and manages it. You can configure payment methods, orders, company logo and also select custom colour based on your convenience. Razorpay supports these payment methods and international currencies.

Configuration

use Lazervel\PGI\Razorpay;

require 'vendor/autoload.php';
$rzp = new Razorpay;

Create an Order in Server

In the sample app, the index.php file contains the code for order creation using Orders API.

$rzp->order(50,'INR');

// Error Handling
$rzp->then(function($response) {
  print_r($response);
})->catch(function($err) {
  die($err);
});

Verify Payment Signature

This is a mandatory step that allows you to confirm the authenticity of the details returned to the checkout for successful payments.


$orderId   = $_SESSION['razorpay_order_id'];   // Where you stored
$paymentId = $_SESSION['razorpay_payment_id']; // Where you stored
$signature = $_SESSION['razorpay_signature'];  // Where you stored

// All parameter is required
$rzp->verifySignature($orderId, $paymentId, $signature);

// Error Handling
$rzp->then(function($payment) {
  // Success payment
  print_r($payment);
})->catch(function($err) {
  // Failed payment
  die($err);
});

License

Licensed Under MIT

Contributing

Pull requests are welcome! For major changes, please open an issue first to discuss what you would like to change.

Resources

Report issue and send Pull Request in the main Lazervel repository

Event-driven cookie manager for the modern web.

Indian Modassir — Sun, 31 Aug 2025 18:05:43 +0000

Lightweight, event-driven cookie manager for parsing, setting, and tracking cookies with ease.

Installation

To include cookie-events in Node, first install with npm.

npm install cookie-events

How to build cookie-events

Clone a copy of the main cookie-events git repo by running:

git clone git://github.com/jsvibe/cookie-events.git

Including cookie-events

Below are some of the most common ways to include cookie-events.

Browser

CDN Link

<script src="https://cdn.jsdelivr.net/npm/cookie-events@1.0.0/lib/cookie.min.js"></script>

You can add the script manually to your project:

<script src="cookie.js"></script>

ESM

import cookieEvents from 'cookie-events'
const cookie = new cookieEvents;

Webpack / Browserify / Babel

There are several ways to use Webpack, Browserify or Babel. For more information on using these tools, please refer to the corresponding project's documentation. In the script, including cookie-events will usually look like this:

import cookieEvents from 'cookie-events'
const cookie = new cookieEvents;

Methods or Features

This library provides a robust and modern API for managing browser cookies, with support for creation, retrieval, updates, deletion, and real-time event handling.

Methods	Description
set	Creates a new cookie with optional attributes (expires, path, domain, etc).
getAll	Returns all cookies as a key-value object.
store	Exposes the internal cookie store object.
param	Converts cookies into a query-style string (e.g., `name=John&age=30`).
get	Retrieves the value of a specific cookie by key.
update	Updates an existing cookie’s value and attributes.
json	Converts all cookies into a JSON string.
UTC	Converts a custom date string into a UTC-formatted string.
parse	Returns cookies as an array of `[key, value]` pairs.
has	Checks if a cookie with the given key exists.
remove	Deletes a specific cookie by setting expiry in the past.
clear	Asynchronously clears all cookies using the Cookie Store API.
on	Registers event listeners for cookie changes (insert, update, delete, etc).

set

Creates or overwrites a cookie with optional attributes.

Parameters:

key (String) Name of the cookie.
value (Any) Value to store (objects/arrays auto-serialized as JSON).
expires (String | Number) Expiry date (UTC string) or max-age in seconds.
path (String, optional) Path scope (default: /).
domain (String, optional) Domain scope.
secure (Boolean, optional) If true, cookie only sent over HTTPS.
SameSite (String, optional) "Strict", "Lax", or "None".

Example:

const Cookie = new Cookie;
Cookie.set("theme", "dark", Cookie.UTC("2025-12-31 23:59:59"));

getAll

Returns all cookies as a key-value object.

Example:

const Cookie = new Cookie;
console.log(Cookie.getAll()); // Output: e.g, { theme: "dark", user: { id: 1 } }

store

Exposes the internal cookie store object (for debugging/inspection).

Example:

const Cookie = new Cookie;
console.log(Cookie.store);

param

Converts cookies into a query-style string.

Example:

const Cookie = new Cookie;
console.log(Cookie.param()); // Output: e.g, "theme=dark&user=%7B%22id%22%3A1%7D"

get

Retrieves the value of a cookie by its name.

Parameters:

key (String) Cookie name.
Returns: Value (Any) or null if not found.

Example:

const Cookie = new Cookie;
console.log(Cookie.get("theme")); // "dark"

update

Updates the value of an existing cookie. Throws error if cookie does not exist.

Parameters:

key (String) Name of the cookie.
value (Any) Value to store (objects/arrays auto-serialized as JSON).
expires (String | Number) Expiry date (UTC string) or max-age in seconds.
path (String, optional) Path scope (default: /).
domain (String, optional) Domain scope.
secure (Boolean, optional) If true, cookie only sent over HTTPS.
SameSite (String, optional) "Strict", "Lax", or "None".

Example:

const Cookie = new Cookie;
Cookie.update("theme", "light", Cookie.UTC("2026-01-01 00:00:00"));

json

Converts all cookies into a JSON string.

Example:

console.log(Cookie.json()); // Output: e.g, {"theme":"dark","user":{"id":1}}

UTC

Converts a date string into UTC format (for expires attribute).

Parameters:

date (String) Example: "2025-12-31 23:59:59"
Returns: String UTC date string.

Example:

const Cookie = new Cookie;
let exp = Cookie.UTC("2025-12-31 23:59:59");
Cookie.set("session", "active", exp);

parse

Parses cookies into an array of [key, value] pairs.

Returns: Array Example: [["theme","dark"], ["user",{id:1}]]

Example:

const Cookie = new Cookie;
console.log(Cookie.parse());

has

Checks if a cookie exists.

Returns: boolean Return true if exists. Otherwise false

Example:

const Cookie = new Cookie;
if (Cookie.has("theme")) {
  console.log("Theme cookie exists!");
}

remove

Deletes a specific cookie by setting its expiry to the past.

Parameters:

key (String) The name of the cookie to remove.
path (String) The path the cookie was set on. Default is "/".
domain (String) The domain the cookie was set on.

Example:

const Cookie = new Cookie;
Cookie.remove("theme");

clear

Asynchronously removes all cookies using the Cookie Store API.

⚠️ Works only in secure contexts (HTTPS) and supported browsers.

Example:

const Cookie = new Cookie;
await Cookie.clear();

on

Registers event listeners for cookie changes.

Parameters:

types (String) Space-separated events (insert, update, delete, clear, change).
callback (Function) Called when event occurs.

const Cookie = new Cookie;
Cookie.on("insert update delete", (e) => {
  console.log("Cookie event:", e.type, e.changed, e.deleted);
});

Supported Events

insert → A new cookie was added.
update → An existing cookie was updated.
delete → A cookie was removed.
clear → All cookies were cleared.
change → Fired on any cookie change.

License

MIT License © 2025 Indian Modassir

See LICENSE for details.

Contributions

Pull requests, bug reports, and feedback are welcome!

Visit the GitHub Repository to contribute.

A lightweight Hindi/English virtual keyboard UI for web applications.

Indian Modassir — Thu, 28 Aug 2025 04:31:10 +0000

✨ Features

🖊️ Hindi + English typing support
🎨 Light / Dark / System theme support with variants
🖥️ On-screen draggable keyboard (movable dialog)
🔀 Language switch (EN ⇄ HI)
⌨️ Special keys (Shift, Caps, Alt, Backspace, Enter, etc.)
📦 Zero dependency, pure JavaScript

Installation

npm install vkbd

or via yarn:

yarn add vkbd

Including vkbd

Below are some of the most common ways to include vkbd.

Browser

CDN Link

<script src="https://cdn.jsdelivr.net/npm/vkbd@1.0.1/lib/vkbd.min.js"></script>

You can add the script manually to your project:

<script src="vkbd.js"></script>

Webpack / Browserify / Babel

import vkbd from 'vkbd';

API Usage

Usage in React

import 'vkbd.css';
import vkbd from 'vkbd';

function App() {

  const kbdUI = new vkbd({
    lang: 'hi',      // 'hi' or 'en'
    theme: 'dark',  // e.g, 'light', 'dark', 'system'
    themeVariant: 1, // 1-3
  });

  // OR
  // const kbdUI = new vkbd();
  // kbdUI.open(inputElement|selector);
  // kbdUI.close();

  return (
    <div>
      <div>
        <input type="text" placeholder="Firstname" id="firstname" />
        <span onClick={() => kbdUI.open("#firstname")}>⌨️</span>
      </div>
      <div>
        <input type="text" placeholder="Surname" id="surname" />
        <span onClick={kbdUI.open("#surname")}>⌨️</span>
      </div>
    </div>
  );
}

export default App;

Output

Usage in Browser

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Virtual Keyboard UI</title>
  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/vkbd@1.0.1/lib/vkbd.min.css">
  <script src="https://cdn.jsdelivr.net/npm/vkbd@1.0.1/lib/vkbd.min.js"></script>

  <!-- Keboard UI Configuration -->
  <script>
    const kbdUI = new vkbd({
      lang: 'hi',      // 'hi' or 'en'
      theme: 'light',  // e.g, 'light', 'dark', 'system'
      themeVariant: 1, // 1-3
    });

    // OR
    // const kbdUI = new vkbd();
    // kbdUI.open(inputElement|selector);
    // kbdUI.close();
  </script>
</head>
<body>
  <div>
    <div>
      <input type="text" placeholder="Firstname" id="firatname" />
      <span onclick="kbdUI.open('#firatname')">⌨️</span>
    </div>
    <div>
      <input type="text" placeholder="Surname" id="surname" />
      <span onclick="kbdUI.open('#surname')">⌨️</span>
    </div>
  </div>
</body>
</html>

Output

Configuration Options

That means the user can set these options (such as lang, theme, themeVariant) to control the keyboard’s language, theme, and style.

Option	Type	Default	Description
lang	string	'hi'	Initial language (`hi` or `en`)
theme	string	'light'	Theme: `light`, `dark`, `system`
themeVariant	number	1	Theme style variant (1–3)

📚 API

vkbd(options) returns a keyboard instance
keyboard.open(elem) open keyboard for given input/textarea
keyboard.close() close keyboard

Contributing

Pull requests are welcome! For major changes, please open an issue first to discuss what you would like to change.

License

Licensed Under MIT

fsMate A modular collection of file system utilities for Node.js

Indian Modassir — Fri, 15 Aug 2025 20:34:56 +0000

fsMate A modular collection of file system utilities for Node.js

It simplifies working with files and directories by providing a higher-level, promise-based API for common file operations such as checking access permissions, creating files/directories, copying files, and mirroring directories.

See Latest Update

Added @see references in JSDoc comments for better documentation and navigation.
Added dirOnly option in scandir() and scandirSync() to list only directories.
Added fileOnly option in scandir() and scandirSync() to list only files.
Added Third filter argument in scandir() and scandirSync() to allow custom filtering (supports array or function).
Improved scandir() documentation with @see reference to official docs.

See Release Notes: 👉 CHANGELOG

Installation

npm install fsmate

Usage

Use this syntax when working in Node.js environments that follow the CommonJS module system.

CommonJS

const fsMate = require('fsmate');

Note: The deprecated constants fs.F_OK, fs.R_OK, fs.W_OK, & fs.X_OK are not exported on Node.js v24.0.0+; please use their fs.constants equivalents.

ESM

There is also an fsmate/esm import, that supports both default and named exports. However, note that fs methods are not included in fsmate/esm; you still need to import fs and/or fs/promises seperately:

import fsMate from 'fsmate/esm';
import {remove, copy, rename} = 'fsmate/esm';

but you probably want to just use regular fsmate instead of fsmate/esm for default exports:

import fsMate from 'fsmate';

Async vs Async/Await vs Sync

All async methods will return a promise

JavaScript handles file operations in three ways: Promises run tasks in the background with .then() / .catch(), async/await makes them look sequential, and synchronous methods pause execution until the task finishes—simple and straightforward.

Example:

const fsMate = require('fsmate');

// Async with Promises:
fsMate.mirror('/home/user/myDir', '/home/user/mirrorDir')
.then(() => console.log('success'))
.catch(err => console.log(err));

// With async/await:
async function mirror(originDir, targetDir) {
  try {
    await fsMate.mirror(originDir, targetDir);
    console.log('success');
  } catch(err) {
    console.log(err);
  }
}

mirror('/home/user/myDir', '/home/user/mirrorDir');

// Sync:
try {
  fsMate.mirrorSync('/home/user/myDir', '/home/user/mirrorDir');
  console.log('success');
} catch(err) {
  console.log(err);
}

Learn for more Documentation see: more

Methods And Features

Async

Method	Description
isExecutable	Check if a file/directory has execute permissions.
isFile	Check if the given path is a regular file.
isDir	Check if the given path is a directory.
isLink	Check if the given path is a symbolic link.
isReadable	Check if a file/directory has read permissions.
isWritable	Check if a file/directory has write permissions.
mkdir	Creates a directories recursively.
mkfile	Create an empty files (or overwrite if specified).
exists	Check if a file or directory exists.
touch	Create a file if it doesn’t exist or update its timestamp.
rename	Rename or move a file/directory.
scandir	List files and directories in a given folder.
remove	Safely remove files or directories (with rename trick).
rm	Remove files or directories using native `fs.rm`.
mirror	Recursively copy an entire directory tree.
copy	Copy a single file with overwrite control.
empty	Remove all contents inside a file or directory without deleting it.
prependFile	Add content at the beginning of a file.
readFile	Read a file's content (optionally parse JSON).
readLine	Read a file line-by-line with range support.
writeFile	Write content to a file (overwrites existing).
appendFile	Append content to the end of a file.
dumpFile	Atomically write a file by first writing to a temp file.

Sync

Method	Description
isExecutableSync	Sync check for execute permissions.
isLinkSync	Sync check if path is a symbolic link.
isFileSync	Sync check if path is a regular file.
isDirSync	Sync check if path is a directory.
isReadableSync	Sync check for read permissions.
isWritableSync	Sync check for write permissions.
mkdirSync	Sync creates a directories recursively.
mkfileSync	Create an empty files (or overwrite if specified).
touchSync	Sync create/update file timestamp.
renameSync	Sync rename or move a file/directory.
scandirSync	Sync list directory contents.
removeSync	Sync safe remove (with rename trick).
appendFileSync	Sync append content to a file.
emptySync	Sync remove all contents inside a file/directory.
mirrorSync	Sync recursively copy a directory tree.
copySync	Sync copy a single file.
readFileSync	Read a file's content (optionally parse JSON).
rmSync	Sync remove file/directory using native `fs.rm`.
readLineSync	Sync read file line-by-line.
writeFileSync	Sync write content to a file.
prependFileSync	Sync add content at file start.
dumpFileSync	Sync atomic file write.

Other Methods

Method	Description
multiStream	Merge multiple readable streams into one.
stringify	Convert different data types to a string safely.
tmpName	Generate a random temporary file/directory name.
tempNam	Generate a SHA1-hash-based temp file name.
createInputStream	Convert string, Buffer, or object into a readable stream.

Contributing

Pull requests are welcome! For major changes, please open an issue first to discuss what you would like to change.

License

Licensed Under MIT

A web-based tool for developers to test APIs

Indian Modassir — Thu, 14 Aug 2025 08:09:47 +0000

A fully functional Postman web application for API testing and development, built with PHP and modern web technologies. This project mimics the core functionalities of Postman, enabling easy creation and management of API requests.

Features

Create and send HTTP requests (GET, POST, PUT, DELETE, PATCH, etc.)
Customize request headers and body (JSON, form-data, etc.)
View response status, headers, and body
Save and organize requests into collections
Request history
Syntax highlighting for JSON and other formats
Intuitive user interface

Technologies Used

Composer for dependency management
JavaScript, HTML5, CSS3 for frontend
cURL or GuzzleHTTP for sending HTTP requests

Installation

Prerequisites

PHP >= 7.4 (or your required PHP version)
Composer installed globally (Get Composer)

Steps

Add the package via Composer

composer create-project indianmodassir/postman

See live Demo: Click now

PHP Dotenv Loads environment variables

Indian Modassir — Wed, 13 Aug 2025 19:42:18 +0000

Loads environment variables from .env to getenv(), $_ENV and $_SERVER automatically.

Installation

Installation is super-easy via Composer

composer require lazervel/dotenv

or add it by hand to your composer.json file.

Usage

use Lazervel\Dotenv\Dotenv;
require 'vendor/autoload.php';

If already .env file existing on current directory

$dotenv = Dotenv::process(__DIR__);
$dotenv->load();

If already .env file existing on current directory without throwing error

$dotenv = Dotenv::process(__DIR__);
$dotenv->safeLoad();

If already .env file existing on current directory

$dotenv = Dotenv::process(__DIR__, 'myconfig.env');
$dotenv->load();

Loads multiple .env files.

$dotenv = Dotenv::process(__DIR__, ['.env.local', '.env.example', '.env'], false);
$dotenv->load();

All of the defined variables are now available in the $_ENV and $_SERVER super-globals.

$s3_bucket = $_ENV['S3_BUCKET'];
$s3_bucket = $_SERVER['S3_BUCKET'];

Nesting Variables

It's possible to nest an environment variable within another, useful to cut down on repetition.

This is done by wrapping an existing environment variable in ${…} e.g.

BASE_DIR="/var/webroot/project-root"
CACHE_DIR="${BASE_DIR}/cache"
TMP_DIR="${BASE_DIR}/tmp"

Requiring Variables to be Set

PHP dotenv has built in validation functionality, including for enforcing the presence of an environment variable. This is particularly useful to let people know any explicit required variables that your app will not work without.

You can use a single string:

$dotenv->required('DATABASE_DSN');

Or an array of strings:

$dotenv->required(['DB_HOST', 'DB_NAME', 'DB_USER', 'DB_PASS']);

Security

If you discover a security vulnerability within this package, All security vulnerabilities will be promptly addressed. You may view our full security policy here.

License

PHP dotenv is licensed under MIT License.

Quanter A pure-JavaScript CSS Selector Engine

Indian Modassir — Tue, 12 Aug 2025 20:26:56 +0000

A Pure-JavaScript, CSS selector engine designed to be easily select DOM-Elements.

Browser support

How to install Quanter

To include Quanter in Node, first install with npm.

npm install quanter

How to build Quanter

Clone a copy of the main Sizzle git repo by running:

git clone git://github.com/jsvibe/quanter.git

In the quanter/dist folder you will find build version of sizzle along with the minified copy and associated map file.

Including Quanter

Below are some of the most common ways to include Quanter.

Browser

<script src="https://cdn.jsdelivr.net/npm/quanter@4.4.0/dist/quanter.min.js"></script>

Webpack / Browserify / Babel

import quanter from "quanter";

Quanter library includes all types of selectors. This will prove to be a good useful library for your web applications and projects.

Quanter library does a lot with less code. It shortens the code used in your projects or web applications. Due to which the performance of your webapp or projects will remain good. It selects advanced and complicated selectors of DOM elements very easily and in less code. This will save you coding time and writing more code.

Form & CSS3 Pseudo Selectors

:get/:post Form elements with the specified method get or post
:required Input required elements.
:read-only Input readOnly elements.
:valid/:invalid Input valid field elements. / Input invalid field elements.
:optional Element that does not have the required attribute set on it.
:writable Writable none-readonly/none-disabled Input elements
:input Input elements
:indeterminate Matches form controls (e.g., checkboxes) in an indeterminate state.
:open Matches elements like <details>/<dialog> that are currently open.
:out-of-range Matches input elements whose value is outside the allowed range.
:in-range Matches input elements whose value is within the allowed range.
:link Matches <a> or <area> elements with an unvisited hyperlink.
:modal Matches elements (like dialogs) that are displayed as modal dialogs.
:paused Matches media elements (e.g.,<video>) that are currently paused.
:muted Matches media elements that are muted.
:autoplay Matches media elements that are set to autoplay.
:picture-in-picture Matches video elements that are in picture-in-picture mode.
:popover-open Matches elements with the popover attribute that are currently shown.
:fullscreen Matches the element that is currently in fullscreen mode.
:playing Matches media elements that are currently playing.
:defined Matches custom elements that have been defined with customElements.define().
:dir Matches elements based on text direction: e.g., :dir(ltr) or :dir(rtl).
:default Input default checked or option default selected elements.
:button Input elements that are buttons or have type "button"
:checkbox, :file, :image, :password, :radio, :reset, :submit, :text, :search, :range, :url, :color, :email, :number Input elements with the specified type.

Positional Pseudo Selectors

:first/:last The first/last matching element
:eq/:nth The nth element; e.g. :eq(6) finds the 7th element
:lt/:gt Elements at positions above/below the specified position
:odd/:even Even/odd-numbered elements
:fixed Matching position:fixed element

Script Pseudo Selectors

:importmap/:ecmascript The type="ecmascript|importmap" script element
:json Script elements with type application/json
:module Script elements with type module

Meta Pseudo Selectors

:theme All theme-color or address-bar color-theme meta elements.
:viewport Meta viewport element. <meta name="viewport" content="width=device-width, initial-scale=1.0">

Containing Pseudo Selectors

:contains(TEXT) Elements with textContent containing the word 'TEXT'. Case-sensitive.
:rcontains(REGEX) Elements with textContent containing the word '/(?:foo|bar)/' Regular-expression.
:icontains(TEXT) Elements with textContent containing the word 'TEXT'. Case-insensitive.
:ircontains(REGEX) Elements with textContent containing the word '/(?:foo|bar)/' Regular-expression Case-insensitive.

CSS3 CHILD Pseudo Selectors

:nth-last-of-type(n) The pattern for matching elements, counting from the end.
:first-child The first matching element among a group of sibling elements.
:first-of-type The first element of its typee among a group of sibling elements.
:last-child The last matching element among a group of sibling elements.
:last-of-type The last element of its typee among a group of sibling elements.
:nth-child(n) Takes a single argument that describes a pattern for matching element indices in a list of siblings.
:only-of-type The represents an element that has no siblings of the same type.
:nth-of-type(n) The matches elements based on their position among siblings of the same type (tag name).
:nth-last-child(n) The matches elements based on their position among a group of siblings, counting from the end.
:only-child The represents an element without any siblings. :first-child:last-child or :nth-child(1):nth-last-child(1), but with a lower specificity.

Others Pseduo Selectors

:parent Elements with at least one child node (either text or an element).
:empty The :empty represents any element that has no children.
:not(h1) Selects elements that do not match the given selector inside the :not(...).
:lang(en) Selects all elements that match the specified language code.
:target Element id matching from origin #hash
:focus Focusable focused elements.
:checked Input checked elements or select in option selected elements.
:enabled/:disabled The enabled Select none-disabled Elements. and disabled Select disabled Elements.
:root Root elements html
:selected (option) elements that are currently selected
:link A proper valid anchor Elements with none-empty href
:filter(h2) Filter matched element of given elements list.
:where(h2, h3) Similar to :is(...), but has no specificity weight.
:has(input) Selects elements that contain an <input> element inside them.
:visible/:hidden hidden or visible elements. Support (visibility, hidden, display)
:header Header elements (h1, h2, h3, h4, h5, h6).
:animated Elements that have CSS animation.
:offset none-static position elements.
:editable Containing the contenteditable=true attribute.
:active Focused or active Elements.
:inline Inline elements (img, input, meta, area...) etc.
:xpath(expr) Select elements using from XPath expression.
:role(button)
:charset(utf-8) Selects all elements that match the specified charset code. (Unavailable 🚫)

Combinators

< The child selector selects all elements that are the parent of a specified element.
> The child selector selects all elements that are the children of a specified element.
+ The adjacent sibling selector is used to select an element that is directly after another specific element.
~ The general sibling selector selects all elements that are next siblings of a specified element.
The descendant selector matches all elements that are descendants of a specified element.

API

How to use and configure Quanter public API

Public API

The Quanter method allows for flexible element selection using a wide range of selector types:

✅ CSS Selectors

Supports tag names, class selectors (.class), ID selectors (#id), attribute selectors ([attr=value]), and pseudo-classes (like :nth-child, :first-of-type, etc.).
⚠️ Limited XPath Support

Basic XPath expressions are supported, but with limited syntax recognition. Use only for simple XPath needs.

Best Use: When your use case involves a mix of CSS-style selectors and simple XPath, and you want to avoid switching methods.

Signature and Parameters:

Quanter(String expr, DOMNode context, Array results, Array seed);

selector [required] A CSS Selector or XPath Expression (comma separated or non-comma separated)
context [optional] An element, document, or document fragment to use as the context for finding elements.
results [optional] An optional array to which the matched elements will be added.
seed [optional] A set of elements to match against

Example

Sample HTML

<div id="main">
  <h1 class="title">Welcome</h1>

  <ul class="items">
    <li data-id="1" class="fruit">Apple</li>
    <li data-id="2" class="fruit special">Banana</li>
    <li data-id="3" class="fruit">Cherry</li>
  </ul>

  <p class="info">Contact us at <span>support@example.com</span></p>

  <div class="products">
    <article data-stock="true" data-type="phone">
      <h2>iPhone 15</h2>
      <span class="price">$999</span>
    </article>
    <article data-stock="false" data-type="phone">
      <h2>Galaxy S25</h2>
      <span class="price">$899</span>
    </article>
    <article data-stock="true" data-type="laptop">
      <h2>MacBook Pro</h2>
      <span class="price">$1999</span>
    </article>
  </div>

  <a href="/login">Login</a>
  <a href="/register">Register</a>
</div>

Quanter Selector Examples (With Multiple Comma-Separated Selectors)

Basic (Comma-separated selectors)

ID + Class Selector

Quanter("#main, .title");

Expected Output:

<div id="main">...</div>
<h1 class="title">Welcome</h1>

Class + Tag Selector

Quanter(".fruit, h1");

Expected Output:

<li data-id="1">Apple</li>
<li data-id="2" class="fruit special">Banana</li>
<li data-id="3">Cherry</li>
<h1 class="title">Welcome</h1>

Attribute + Positional

Attribute Equals + First Child

Quanter("li[data-id='2'], ul.items li:first-child");

Expected Output:

<li data-id="2" class="fruit special">Banana</li>
<li data-id="1">Apple</li>

Attribute Contains + Last Child

Quanter("a[href*='reg'], ul.items li:last-child");

Expected Output:

<a href="/register">Register</a>
<li data-id="3">Cherry</li>

Combinators + Multiple Filters

*Descendant + Direct Child"

Quanter(".products .price, .products > article");

Expected Output:

All <span class="price"> elements inside .products
All direct <article> elements inside .products

Multiple Attributes

Quanter("article[data-stock='true'][data-type='phone'], article[data-type='laptop']");

Expected Output:

<article data-stock="true" data-type="phone">iPhone 15</article>
<article data-stock="true" data-type="laptop">MacBook Pro</article>

Pseudo & Complex Chains

First-child + Not Selector

Quanter("ul.items li:first-child, li:not(.special)");

Expected Output:

<li data-id="1">Apple</li>
<li data-id="1">Apple</li> (duplicate match from both selectors)
<li data-id="3">Cherry</li>

Contains Text + Class

Quanter(":contains('Apple'), .special");

Expected Output:

<li data-id="1">Apple</li>
<li data-id="2" class="fruit special">Banana</li>

Advanced Combined Queries

Grouping Complex Paths

Quanter("div#main .products > article[data-stock='true'] .price, li.fruit:last-child");

Expected Output:

<span class="price">$999</span> (iPhone 15)
<span class="price">$1999</span> (MacBook Pro)
<li data-id="3">Cherry</li>

Universal Selector with Attribute Filter + Multiple Tags

Quanter("*[data-id], h1, a[href='/login']");

Expected Output:

All <li> elements with data-id (Apple, Banana, Cherry)
<h1 class="title">Welcome</h1>
<a href="/login">Login</a>

📌 Notes

All selectors here are comma-separated to demonstrate grouping in Quanter.
You can mix any number of selectors in one Quanter call.
Duplicate matches will not be automatically removed; use Array.from(new Set(...)) if needed.

Learn for more documentation

XPath Selector

The XPathSelect method is a specialized function built to handle full XPath syntax, offering complete support for:

Complex queries
Nested expressions
Axes like following-sibling, ancestor, descendant
Functions like contains(), starts-with(), text(), etc.

Best Use: When your use case requires powerful and deeply nested element queries using the full capabilities of XPath.

Signature and Parameters:

Quanter.XPathSelect(String expr, DOMNode context, Array results, Array seed);

expr[required] A XPath Expression (comma separated or non-comma separated)
context [optional] An element, document, or document fragment to use as the context for finding elements.
results [optional] An optional array to which the matched elements will be added.
seed [optional] A set of elements to match against

Example

Sample HTML

<html>
  <body>
    <div id="main">
      <h1 class="title">Welcome</h1>
      <ul class="items">
        <li data-id="1">Apple</li>
        <li data-id="2">Banana</li>
        <li data-id="3">Cherry</li>
      </ul>
      <a href="/login">Login</a>
      <p>  Contact us at <span>support@example.com</span>  </p>
      <div class="footer">© 2025 Company</div>
      <section class="products">
        <article data-stock="true">
          <h2>iPhone 15</h2>
          <span class="price">$999</span>
        </article>
        <article data-stock="false">
          <h2>Galaxy S25</h2>
          <span class="price">$899</span>
        </article>
      </section>
    </div>
  </body>
</html>

Select all <h1> elements

Quanter.XPathSelect('//h1');

Element with attribute id="main"

Quanter.XPathSelect('//*[@id="main"]');

Attribute starts-with (href starting with /log)

Quanter.XPathSelect('//a[starts-with(@href, "/log")]');

Exact text match (li with text "Banana")

Quanter.XPathSelect('//li[text()="Banana"]');

First <li> inside ul.items

Quanter.XPathSelect('//ul[@class="items"]/li[1]');

Last <li> inside ul.items

Quanter.XPathSelect('//ul[@class="items"]/li[last()]');

Following sibling of <a> (first <p> after it)

Quanter.XPathSelect('//a/following-sibling::p[1]');

Select products that are in stock (data-stock="true")

Quanter.XPathSelect('//section[@class="products"]/article[@data-stock="true"]');

Select price of the out-of-stock product

Quanter.XPathSelect('//article[@data-stock="false"]/span[@class="price"]/text()');

Usage Multiple Expr With Comma Separated

Quanter.XPathSelect('//article[@data-stock="false"]/span[@class="price"]/text(), //section[@class="products"]/article[@data-stock="true"], //a/following-sibling::p[1]');

Learn for more documentation

JavaScript sprintf implementation

Indian Modassir — Sat, 09 Aug 2025 00:07:37 +0000

🌟 Features

Fully functional printf, sprintf, and vsprintf methods.
C-style format specifiers support:
- %d, %f, %s, %x, %b, %o, %u, %c, %e, %g, %G, etc.
Padding, alignment, width, and precision controls
Argument indexing like %2$08.2f
Supports most common C-style format specifiers.
Distinct handling for %f (locale) and %F (non-locale)
Float, Integer, Hex, Octal, Binary, Char, and String formatting
Custom width, padding, alignment flags.
Float precision control up to JavaScript's max (53 bits).
Handles NaN, Infinity and signed values.
Works in Node.js, modern browsers, and CommonJS/AMD environments.
No external dependencies

How to install printfy

To include printfy in Node, first install with npm.

npm install printfy

How to build printfy

Clone a copy of the main Sizzle git repo by running:

git clone git://github.com/jsvibe/printfy.git

In the printfy/dist folder you will find build version of printfy along with the minified file.

Including printfy

Below are some of the most common ways to include printfy.

Browser

CDN Link

<script src="https://cdn.jsdelivr.net/npm/printfy@2.0.2/dist/printfy.min.js"></script>

You can add the script manually to your project:

<script src="printfy.js"></script>

Webpack / Browserify / Babel

import {sprintf, printf, vprintf, vsprintf} from "printfy";

Node.js

Fully compatible with Node.js, this library lets you use familiar C-style printf formatting in server-side code—ideal for CLI tools, logging, and backend output formatting.

const {sprintf, printf, vprintf, vsprintf} = require("printfy");

API Usage

`printf(format, ...args)`

Logs the formatted output to the console.

printf("Hello %s, you have %d new messages", "Alice", 5);
// Output: Hello Alice, you have 5 new messages

`vprintf(format, args[])`

Logs the formatted output to the console.

printf("Hello %s, you have %d new messages", [ "Alice", 5]);
// Output: Hello Alice, you have 5 new messages

`sprintf(format, ...args)`

Returns a formatted string (like sprintf in C).

let result = sprintf("Value: %08.2f", 3.14);
console.log(result); // Output: Value: 00003.14

`vsprintf(format, args[])`

Same as sprintf, but accepts arguments as an array.

vsprintf("User: %s, Score: %d", ["Bob", 100]);
// Output: User: Bob, Score: 100

🔢 Supported Specifiers

A argument based sprint specifieee

Specifier	Meaning	Example
`%s`	String	`sprintf("%s", "abc")` → `"abc"`
`%S`	Uppercase string	`"abc"` → `"ABC"`
`%d`	Integer (decimal)	`42`
`%u`	Unsigned integer (64-bit)	`-1` → `"18446744073709551615"`
`%b`	Binary	`5` → `"101"`
`%o`	Octal	`8` → `"10"`
`%x`, `%X`	Hexadecimal (lower/upper)	`255` → `"ff"` or `"FF"`
`%f`, `%F`	Float (fixed-point)	`3.14` → `"3.140000"`
`%e`, `%E`	Float (scientific notation)	`3.14` → `"3.14e+0"`
`%g`, `%G`	Auto float/scientific (shortest form)	`123000` → `"1.23e+5"`
`%c`	Character from ASCII code	`65` → `"A"`
`%%`	Literal percent sign	`%`

Supported Specifiers

A non-argument base date-time format specifiers

Specifier	Description
$d	Day of the month, 2 digits with leading zeros (e.g., `01` to `31`)
$D	A textual representation of a day, three letters (e.g., `Mon` to `Sun`)
$j	Day of the month without leading zeros (e.g., `1` to `31`)
$l	(lowercase 'L'): A full textual representation of the day of the week (e.g., `Sunday` to `Saturday`)
$N	ISO-8601 numeric representation of the day of the week (e.g., `1` for `Monday` to `7` for `Sunday`)
$S	English ordinal suffix for the day of the month, 2 characters (e.g., `st`, `nd`, `rd`, `th`)
$w	Numeric representation of the day of the week (e.g., `0` for `Sunday` to `6` for `Saturday`)
$z	The day of the year (starting from 0) (e.g., 0 to 365)
$W	ISO-8601 week number of year, weeks starting on Monday (e.g., `01` to `53`)
$F	A full textual representation of a month (e.g., `January` to `December`)
$m	Numeric representation of a month, with leading zeros (e.g., `01` to `12`)
$M	A short textual representation of a month, three letters (e.g., `Jan` to `Dec`)
$n	Numeric representation of a month, without leading zeros (e.g., `1` to `12`)
$t	Number of days in the given month (e.g., `28` to `31`)
$L	Whether it's a leap year (e.g., `1` for leap year, `0` otherwise)
$o	ISO-8601 week-numbering year. This has the same value as Y, except that if the ISO week number (W) belongs to the previous or next year, that year is used instead (e.g., `1999` or `2003`)
$y	A two-digit representation of a year (e.g., 99 or 03)
$Y	A full numeric representation of a year, 4 digits (e.g., `1999` or `2003`)
$a	Lowercase am or pm
$A	Uppercase AM or PM
$g	12-hour format of an hour without leading zeros (e.g., `1` to `12`)
$G	24-hour format of an hour without leading zeros (e.g., `0` to `23`)
$h	12-hour format of an hour with leading zeros (e.g., `01` to `12`)
$H	24-hour format of an hour with leading zeros (e.g., `00` to `23`)
$i	Minutes with leading zeros (e.g., `00` to `59`)
$s	Seconds with leading zeros (e.g., `00` to `59`)
$I	(capital 'i'): Whether or not the date is in daylight saving time (e.g., `1` for DST, `0` otherwise)
$O	Difference to Greenwich time (GMT) in hours (e.g., `+0200`)
$p	Difference to Greenwich time (GMT) with colon between hours and minutes (e.g., `+05:30`, `-04:00`)
$t	Number of days in the given month (e.g., `28`, `29`, `30`, `31`)
$r	RFC 2822 formatted date (e.g., `Thu, 21 Dec 2000 16:01:07 +0200`)

⚙️ Format Options

Format syntax:

%[index$][padding][flag][width][.precision]specifier

🧪 Examples

sprintf("Binary: %08b", 5);          // Binary: 00000101
sprintf("Hex: %#x", 255);            // Hex: ff
sprintf("Char: %c", 65);             // Char: A
sprintf("Padded: %10s", "text");     // Padded:      text
sprintf("Left: %-10s!", "text");     // Left: text     !
sprintf("Float: %.2f", 3.14159);     // Float: 3.14
sprintf("Scientific: %.2e", 1200);   // Scientific: 1.20e+3

[index$] – Argument Indexing

sprintf('%2$s is %1$d years old.', 22, 'Modassir');
// Output: Modassir is 22 years old.

[padding] – Custom Padding Character

sprintf("%'~5d", 42);
// Output: ~~~42

sprintf("%'~-5d", 42);
// Output: 42~~~

[flag] – Format Flags

Support flags + and - only.

sprintf("%+d", 42);
// Output: +45

sprintf("%-d", 42);
// Output: -45

[width] – Custom Width

sprintf("%6s", "JS");
// Output: "    JS"

sprintf("lang%6s", "JS");
// Output: "lang    JS"

sprintf("%-6s", "JS");
// Output: "JS    "

sprintf("%-6slib", "JS");
// Output: "JS    lib"

[.precision] – Precision (floating-point or string truncation)

sprintf("%.2f", 3.14159);
// Output: 3.14

sprintf("%.4s", "OpenAI");
// Output: Open

Full Format

sprintf('%2$\'#-+10.2f and %1$\'*_10s', "JS", 3.14159);
// Output: +3.14#####JS*******

🔹 Explanation:

%2$: Second argument (3.14159)
'#: padding character #
-: left align
+: show sign
10: total width 10
.2f: 2 decimal places
%1$'*_10s: First argument (JS), padded with * to width 10

⚠️ Errors & Warnings

ArgumentCountError: Thrown if insufficient arguments are passed for format specifiers.
ValueError: Invalid specifier detected.
RangeError: Padding exceeds safe integer limit.
Precision Truncation: Float precision is capped at JavaScript's safe limit (53 digits).

🔄 Comparison with Other Libraries

Feature / Library	printfy ✓	sprintf-js 🟡	fast-printf 🟢	printf (npm) 🔵
C-style specifiers	✓ Full	✓ Full	✓ Partial	✓ Partial
%2\$ style arg index	✓ Yes	✓ Yes	✗ No	✗ No
BigInt support	✓ Yes	✗ No	✗ No	✗ No
%f vs %F (locale)	✓ Separate	✗ Combined	✗ Combined	✗ No
Custom padding ('x)	✓ `'x`, `0`, etc.	✗ No	✗ No	✗ No
String return (sprintf)	✓ Yes	✓ Yes	✓ Yes	✗ No
Lightweight / No deps	✓ Yes	✓ Yes	✓ Yes	✓ Yes
Unicode emoji safe	Partial	Partial	✗ No	✗ No
Performance	Good	Good	Best	Good

📦 Module Support

This library supports the following environments:

Browser (<script>)
CommonJS / Node.js
AMD (Asynchronous Module Definition)

🔐 License

MIT License © 2025 Indian Modassir

See LICENSE for details.

🙌 Contributions

Pull requests, bug reports, and feedback are welcome!

Visit the GitHub Repository to contribute.

PHP Path

Indian Modassir — Fri, 08 Aug 2025 23:38:18 +0000

PHP Path Help with handling or manipulating file and directory path.

Composer Installation

Installation is super-easy via Composer

composer require lazervel/path

or add it by hand to your composer.json file.

use Lazervel\Path\Path;
require 'vendor/autoload.php';

The Features of PHP Path

Path::basename($path[, $suffix])
Path::canonicalize($path)
Path::changeExt($path, $newExt)
Path::combine($paths, $names)
Path::checkLength($path)
Path::delimiter
Path::dirname($path[, $suffix, $levels])
Path::extname($path)
Path::filename($path)
Path::format($pathObject)
Path::getcwd()
Path::hasExt($path)
Path::info()
Path::isAbsolute($path)
Path::isLocal($path)
Path::isURIPath($path)
Path::join([...$paths])
Path::localBase($paths)
Path::normalize($path)
Path::optimize($path)
Path::parse($path)
Path::pathname($path)
Path::pathToURL($path, $origin[, ?$query, ?$hash])
Path::posix
Path::relative($from, $to)
Path::removeExt($path)
Path::resolve(...$paths)
Path::rootname($path)
Path::sep
Path::tmp($path)
Path::toNamespacedPath($path)
Path::UrlToPath($url)
Path::win32

Path::basename($path[, $suffix])

Parameters:

$path string
$suffix string An optional suffix to remove
Return: string

The Path::basename() method returns the last portion of a path, similar to the Unix basename command. Trailing directory separators are ignored.

For example, on POSIX:

Path::basename('C:\\xampp\\htdocs\\example.html');
// Returns: 'example.html'

Path::basename('C:\\xampp\\htdocs\\example.html', '.html');
// Returns: 'example'

On Windows:

Path::basename('/home/local/user/example.html');
// Returns: 'example.html'

Path::basename('/home/local/user/example.html', '.html');
// Returns: 'example'

Path::canonicalize($path)

Parameters:

$path string
Return: string

canonicalize function converts a given path into its canonical (absolute and standardized) form. It resolves relative paths, symbolic links, and eliminates redundant or unnecessary components
like '.' and '..' to return a clean and absolute version of the path.

For example, on POSIX:

Path::canonicalize('C:\\XamPP\\HtDocS\\DatA\\comPoseR.jSon');
// Returns: 'C:\\xampp\\htdocs\\data\\composer.json'

On Windows:

Path::canonicalize('/path/composer.json');
// Returns: 'G:\\path\\composer.json'

Path::changeExt($path, $newExt)

Parameters:

$path string
$newExt string
Return: string

Returns a path string with changed initial extension to replaced new extension.

If path extension and givent new extension are same then changeExt will be not modify and return path with initial extension.

Path::changeExt('/foo/bar/baz/asdf/quux.html', '.php');
// Returns: '/foo/bar/baz/asdf/quux.php'

Path::changeExt('/foo/bar/baz/asdf/vector.gif', 'svg');
// Returns: '/foo/bar/baz/asdf/vector.svg'

Path::combine($paths, $names)

Parameters:

$paths array
$names array
Return: array

Creates an array by using one array for paths and another for its names. And creates multiple files combined with paths from to file names.

For example, on POSIX:

Path::combine(['/xampp/htdocs'], ['example.html', 'foo.txt']);
// Returns: ['/xampp/htdocs/example.html', '/xampp/htdocs/foo.txt']

Path::combine(['/xampp/htdocs'], ['example.html']);
// Returns: ['/xampp/htdocs/example.html']

Path::combine(['/xampp/htdocs', '/path'], ['example.html']);
// Returns: ['/xampp/htdocs/example.html', '/path/example.html']

Path::combine(['/xampp/htdocs', '/path'], ['example.html', 'foot.txt', '.env']);
// Returns: ['/xampp/htdocs/example.html', '/xampp/htdocs/foot.txt', '/xampp/htdocs/.env', '\path\example.html', '\path\foot.txt', '\path\.env']

On Windows:

Path::combine(['C:\\xampp\\htdocs'], ['example.html', 'foo.txt']);
// Returns: ['C:\\xampp\\htdocs\\example.html', 'C:\\xampp\\htdocs\\foo.txt']

Path::combine(['C:\\xampp\\htdocs'], ['example.html']);
// Returns: ['C:\\xampp\\htdocs\\example.html']

Path::combine(['C:\\xampp\\htdocs', '\\path'], ['example.html']);
// Returns: ['C:\\xampp\\htdocs\\example.html', '\\path\\example.html']

Path::combine(['C:\\xampp\\htdocs', '\\path'], ['example.html', 'foot.txt', '.env']);
// Returns: ['C:\\xampp\\htdocs\\example.html', 'C:\\xampp\\htdocs\\foot.txt', 'C:\\xampp\\htdocs\\.env', '\\path\\example.html', '\\path\\foot.txt', '\\path\\.env']

Path::checkLength($path)

Parameters:

$path string
Return: void

Check a valid path length and report exception.

// Check maximum path length on your system use \PHP_MAXPATHLEN constant.
Path::checkLength('your-path');

// Returns: if given path of length are valid so return (void) otherwise throwing RTException Error.
// PHP Fatal error:  Uncaught Path\Exception\RTException: Invalid path because path length exceeds [2048] characters.

Throwing Error

Path\Exception\RTException: Invalid path because path length exceeds [2048] characters.

Path::delimiter

Provides the platform-specific path delimiter:

; for Windows
: for POSIX

For example, on POSIX:

echo getenv('PATH');
// Prints: '/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin'

explode(Path::delimiter, getenv('PATH'));
// Returns: ['/usr/bin', '/bin', '/usr/sbin', '/sbin', '/usr/local/bin']

On Windows:

echo getenv('PATH');
// Prints: 'C:\Windows\system32;C:\Windows;C:\Program Files\node\'

explode(Path::delimiter, getenv('PATH'));
// Returns ['C:\\Windows\\system32', 'C:\\Windows', 'C:\\Program Files\\node\\']

Path::dirname($path[, $suffix, $levels])

Parameters:

$path string
$suffix string
$levels int
Return: string

Get the directory name of a given path with optional suffix removal and level adjustment. This function returns the parent directory's path of the provided file or directory path. It also allows for an optional suffix to be removed from the base name and specifies how many levels up the directory to go.

For example, on POSIX:

Path::dirname('/foo/bar/baz/asdf/quux\\abcd\\xyz');
// Returns: '/foo/bar/baz/asdf'

On Windows:

Path::dirname('/foo/bar/baz/asdf/quux');
// Returns: '/foo/bar/baz/asdf'

Path::dirname('/foo/bar/baz/asdf/quux\\abcd\\xyz');
// Returns: '/foo/bar/baz/asdf/quux\abcd'

Path::extname($path)

Parameters:

$path string
Return: string

Returns extname method a path extension name from given path, Its used to get file extention.

Path::extname('C:\\xampp\\htdocs\\example.html');
// Returns: '.html'

Path::extname('index.coffee.md');
// Returns: '.md'

Path::extname('index.');
// Returns: '.'

Path::extname('index');
// Returns: ''

Path::extname('.index');
// Returns: '.index'

Path::extname('C:\\xampp\\htdocs\\example.md');
// Returns: '.md'

Path::filename($path)

Parameters:

$path string
Return: string

Returns a filename without extention of given path.

Path::filename('/foo/bar/baz/asdf/quux.html');
// Returns: 'quux.html'

Path::filename('example.txt');

Path::filename('/');
// Returns: ''
// Returns: 'example.txt'

Path::filename('example');
// Returns: 'example'

Path::filename('C:\\path\\dir\\file.txt');
// Returns: 'file.txt'

Path::format($pathObject)

Parameters:

$pathObject array
Return: string

Returns a path string from an array-object - the opposite of parse(). format method are same work as phpinfo method But there install the extra property root property to getting current root [dir] of path

For example, on POSIX:

// If `dir`, `root` and `base` are provided,
// `${dir}${Path::sep}${base}`
// will be returned. `root` is ignored.
Path::format([
  'root' => '/ignored',
  'dir' => '/home/user/dir',
  'base' => 'file.txt',
]);
// Returns: '/home/user/dir/file.txt'

// `root` will be used if `dir` is not specified.
// If only `root` is provided or `dir` is equal to `root` then the
// platform separator will not be included. `ext` will be ignored.
Path::format([
  'root' => '/',
  'base' => 'file.txt',
  'ext' => 'ignored',
]);
// Returns: '/file.txt'

// `name` + `ext` will be used if `base` is not specified.
Path::format([
  'root' => '/',
  'name' => 'file',
  'ext' => '.txt',
]);
// Returns: '/file.txt'

// The dot will be added if it is not specified in `ext`.
Path::format([
  'root' => '/',
  'name' => 'file',
  'ext' => 'txt',
]);
// Returns: '/file.txt'

On Windows:

Path::format([
  'dir' => 'C:\\path\\dir',
  'base' => 'file.txt',
]);
// Returns: 'C:\\path\\dir\\file.txt'

Path::getcwd()

Retrieves the current working directory based on the operating system. This method returns the current working directory in a format appropriate for the platform. For POSIX systems, it returns a path like /xampp/htdocs/, while for Windows systems, it returns a path like C:/xampp/htdocs/.

For example, on POSIX:

// If the current working directory is /xampp/htdocs,
Path::getcwd(); // Returns: /xampp/htdocs

On Windows:

// If the current working directory is C:\\xampp\\htdocs,
// returns with drive LIKE (eg: C:,D:,F: etc.)
Path::getcwd(); // Returns: C:\\xampp\\htdocs

Path::hasExt($path)

Parameters:

$path string
Return: bool

hasExt method will check extension exists or not exists of given path and matcher Extensions, if Given extensions in matched path extension then return true, Otherwise return false.

Path::hasExt('/foo/bar/baz/asdf/vector.png', ['.gif', '.jpg', '.png']); // Returns: true
Path::hasExt('/foo/bar/baz/asdf/vector.gif', '.gif');                   // Returns: true
Path::hasExt('/foo/bar/baz/asdf/vector.gif', 'gif');                    // Returns: true
Path::hasExt('/foo/bar/baz/asdf/vector.gif', ['gif', 'jpeg', 'png']);   // Returns: true

Path::hasExt('/foo/bar/baz/asdf/vector.pdf', ['.gif', '.jpg', '.png']); // Returns: false
Path::hasExt('/foo/bar/baz/asdf/vector.gif', '.svg');                   // Returns: false
Path::hasExt('/foo/bar/baz/asdf/vector.gif', 'png');                    // Returns: false
Path::hasExt('/foo/bar/baz/asdf/vector.gif', ['svg', 'jpeg', 'png']);   // Returns: false

Path::info()

Returns information about a file path.

For example, on POSIX:

Path::info('/home/local/user/example.html');
// Returns: stdClass Object (
//   [dirname] => /home/local/user
//   [basename] => example.html
//   [extension] => html
//   [filename] => example
//   [root] => /
// )

On Windows:

Path::info('C:\\xampp\\htdocs\\path\\Path.php');
// Returns: stdClass Object (
//   [dirname] => C:\xampp\htdocs\path
//   [basename] => Path.php
//   [extension] => php
//   [filename] => Path
//   [root] => C:\
// )

Path::isAbsolute($path)

Parameters:

$path string
Return: bool

Determines whether {path} is an absolute path. An absolute path will always resolve to the same location,regardless of the working directory.

For example, on POSIX:

Path::isAbsolute('/foo/bar'); // Returns: true
Path::isAbsolute('/baz/..');  // Returns: true
Path::isAbsolute('qux/');     // Returns: false
Path::isAbsolute('.');        // Returns: false

On Windows:

Path::isAbsolute('//server');    // Returns: true
Path::isAbsolute('\\\\server');  // Returns: true
Path::isAbsolute('C:/foo/..');   // Returns: true
Path::isAbsolute('C:\\foo\\..'); // Returns: true
Path::isAbsolute('bar\\baz');    // Returns: false
Path::isAbsolute('bar/baz');     // Returns: false
Path::isAbsolute('.');           // Returns: false

Path::isLocal($path)

Parameters:

$path string
Return: bool

isLocal function checks whether the provided path is local or not. It determines if the given path refers to a local file or directory.

Path::isLocal('C:Users\JohnDoe\Documents\file.txt');  // Returns: 'false'
Path::isLocal('//home/user/file.txt');                // Returns: 'false'
Path::isLocal('C:\Program Files\file//file.txt');     // Returns: 'false'
Path::isLocal('C:/Windows\\System32');                // Returns: 'false'
Path::isLocal('D:\\Data\report.pdf');                 // Returns: 'false'
Path::isLocal('C:\Users\JohnDoe\Documents\file.txt'); // Returns: 'true'
Path::isLocal('D:\Projects\Code\index.html');         // Returns: 'true'
Path::isLocal('/home/user/documents/report.pdf');     // Returns: 'true'
Path::isLocal('\\ServerName\SharedFolder\image.png'); // Returns: 'true'
Path::isLocal('E:\Music\Rock\song.mp3');              // Returns: 'true'

Path::isURIPath($path)

Parameters:

$path string
Return: bool

Check if the given path is a valid network path. A valid network path starts with two backslashes \\ or // followed by the server name, and can include subdirectories.

Support: working only Windows:

Path::isURIPath('//home/local/user/'); // Returns: true
Path::isURIPath('//home/local');       // Returns: true
Path::isURIPath('//home/local/');      // Returns: true
Path::isURIPath('/server/foo/');       // Returns: false
Path::isURIPath('D:/');                // Returns: false
Path::isURIPath('//home/');            // Returns: false
Path::isURIPath('C:/xampp/htdocs/');   // Returns: false

Path::join([...$paths])

Parameters:

...$paths string
Return: string

Join all arguments together and normalize the resulting path.

Path::join('/foo', 'bar', 'baz/asdf', 'quux', '..');
// Returns: '/foo/bar/baz/asdf'

Path::join('foo', [], 'bar');
// Throws TypeError: Path\Path::join(): Argument #2 must be of type string, array given.

Path::localBase($paths)

// Temporary Unavailable

Path::normalize($path)

Parameters:

$path string
Return: string

Normalize a string path, reducing .. and . parts. When multiple slashes are found, they're replaced by a single one; when the path contains a trailing slash, it is preserved. On Windows backslashes are used.

For example, on POSIX:

Path::normalize('/foo/bar//baz/asdf/quux/..');
// Returns: '/foo/bar/baz/asdf'

On Windows:

Path::normalize('C:\\temp\\\\foo\\bar\\..\\');
// Returns: 'C:\\temp\\foo\\'

Since Windows recognizes multiple path separators, both separators will be replaced by instances of the Windows preferred separator (\):

Path::win32::normalize('C:////temp\\\\/\\/\\/foo/bar');
// Returns: 'C:\\temp\\foo\\bar'

Path::optimize($path)

Optimize method working As Path::format() but this method in common different, This method will be convert backward slashes to forward slash and convert forward slash to backward slash depend on window and posix

Optimize reducing '..' and '.' parts. When multiple slashes are found, they're replaced by a single one; when the path contains a trailing slash, it is preserved. On Windows backslashes are used.

For example, on POSIX:

Path::optimize('C:////temp\\\\/\\/\\/foo/bar');
// Returns: C:/temp/foo/bar

On Windows:

Path::optimize('C:////temp\\\\/\\/\\/foo/bar');
// Returns: C:\\temp\\foo\\bar

Path::parse($path)

Parameters:

$path string
Return: array<string,string>

Returns an object from a path string - the opposite of format().

For example, on POSIX:

Path::parse('/home/user/dir/file.txt');
// Returns:
// [
//   'root' => '/',
//   'dir' => '/home/user/dir',
//   'base' => 'file.txt',
//   'ext' => '.txt',
//   'name' => 'file'
// ]

┌─────────────────────┬────────────┐
│          dir        │    base    │
├──────┬              ├──────┬─────┤
│ root │              │ name │ ext │
"  /    home/user/dir / file  .txt "
└──────┴──────────────┴──────┴─────┘
(All spaces in the "" line should be ignored. They are purely for formatting.)

On Windows:

path.parse('C:\\path\\dir\\file.txt');
// Returns:
// [
//   'root' => 'C:\\',
//   'dir' => 'C:\\path\\dir',
//   'base' => 'file.txt',
//   'ext' => '.txt',
//   'name' => 'file'
// ]

┌─────────────────────┬────────────┐
│          dir        │    base    │
├──────┬              ├──────┬─────┤
│ root │              │ name │ ext │
" C:\      path\dir   \ file  .txt "
└──────┴──────────────┴──────┴─────┘
(All spaces in the "" line should be ignored. They are purely for formatting.)

Path::pathname($path)

Parameters:

$path string
Return: string

Get the path name of a given file or directory. This function returns the path name without any suffix or modification and without drive.

For example, on POSIX:

Path::pathname('//var/www/httpdocs/config/config.yml');
// Returns: '/var/www/httpdocs/config/config.yml'

Path::pathname('C:////temp\\\\/\\/\\/foo/bar');
// Returns: 'C:/temp\foo/bar'

Path::pathname('/');
// Returns: '/'

Path::pathname('/var/www/httpdocs/config/config.yml');
// Returns: '/var/www/httpdocs/config/config.yml'

On Windows:

// Handle Network Path, Here network path are '\\\\var\\www'
Path::pathname('\\\\var\\www\\httpdocs\\config\\config.yml');
// Returns: '\\httpdocs\\config\\config.yml'

Path::pathname('C:////temp\\\\/\\/\\/foo/bar');
// Returns: '\\temp\\foo\\bar'

Path::pathname('\\var\\www\\httpdocs\\config\\config.yml');
// Returns: '\\var\\www\\httpdocs\\config\\config.yml'

Path::pathname('\\\\var\\www\\');
// Returns: '\\'

Path::pathname('C:');
// Returns: ''

Path::pathname('C:\\');
// Returns: '\\'

Path::pathname('\\\\var\\www');
// Returns: ''

Path::pathname('G:var\\www\\httpdocs\\config\\config.yml');
// Returns: 'var\\www\\httpdocs\\config\\config.yml'

Since Windows recognizes multiple path separators, both separators will be replaced by instances of the Windows preferred separator (\):

Path::pathToURL($path, $origin[, ?$query, ?$hash])

Parameters:

$path string
$origin string
$query string
$hash string
Return: string

pathToURL - Convert path to url, Returns path to url combination with (e.g., path, origin, ?query, ?hash).

Notice: Don't use syntax Path::win32::pathToURL() or Path::posix::pathToURL(), This a common bugs. but don't worry we fix this bugs to next expected version [v10.2.0].

For example, on POSIX:

Path::pathToURL('server/auth/client', 'https://www.example.com', 'id=1');
// Returns: 'https://www.example.com/server/auth/client?id=1'

Path::pathToURL('server/auth/client', 'https://www.example.com');
// Returns: 'https://www.example.com/server/auth/client'

Path::pathToURL('server/auth/client', 'https://www.example.com', '?id=1', '#root');
// Returns: 'https://www.example.com/server/auth/client?id=1#root'

Path::pathToURL('server/auth/client', 'https://www.example.com', '?id=1', 'root');
// Returns: 'https://www.example.com/server/auth/client?id=1#root'

On Windows:

Path::pathToURL('G:\\server\\auth\\client', 'https://www.example.com', 'id=1');
// Returns: 'https://www.example.com/server/auth/client?id=1'

Path::pathToURL('G:\\server\\auth\\client', 'https://www.example.com');
// Returns: 'https://www.example.com/server/auth/client'

Path::pathToURL('G:\\server\\auth\\client', 'https://www.example.com', '?id=1', '#root');
// Returns: 'https://www.example.com/server/auth/client?id=1#root'

Path::pathToURL('G:\\server\\auth\\client', 'https://www.example.com', '?id=1', 'root');
// Returns: 'https://www.example.com/server/auth/client?id=1#root'

Path::posix

The Path::posix property provides access to POSIX specific implementations of the Path methods.

The API is accessible via Path\Path::posix or Path\Linux\Linux::class.

Path::relative($from, $to)

Parameters:

$from string
$to string
Return: string

Solve the relative path from from to to based on the current working directory. At times we have two absolute paths, and we need to derive the relative path from one to the other. This is actually the reverse transform of path.resolve.

For example, on POSIX:

Path::relative('/data/orandea/test/aaa', '/data/orandea/impl/bbb');
// Returns: '../../impl/bbb'

On Windows:

Path::relative('C:\\orandea\\test\\aaa', 'C:\\orandea\\impl\\bbb');
// Returns: '..\\..\\impl\\bbb'

Path::removeExt($path)

Parameters:

$path string
Return: string

Returns a path string with removed path extension.

Path::removeExt('/var/www/web.php');
// Returns: '/var/www/web'

Path::removeExt('.env.local');
// Returns: '.env'

Path::removeExt('.html');
// Returns: '' bugs detected

Path::removeExt('file.txt');
// Returns 'file'

Path::removeExt('G:/path/.github');
// Returns: 'G:/path/' bugs detected

Path::resolve(...$path)

Parameters:

...$paths string A sequence of path segments.
Return: string

The right-most parameter is considered to. Other parameters are considered an array of from. Starting from leftmost from parameter, resolves to to an absolute path. If to isn't already absolute, from arguments are prepended in right to left order, until an absolute path is found. If after using all from paths still no absolute path is found, the current working directory is used as well. The resulting path is normalized, and trailing slashes are removed unless the path gets resolved to the root directory.

For example, on POSIX:

Path::resolve('/foo/bar', './baz');
// Returns: '/foo/bar/baz'

Path::resolve('/foo/bar', '/tmp/file/');
// Returns: '/tmp/file'

Path::resolve('wwwroot', 'static_files/png/', '../gif/image.gif');
// If the current working directory is /home/myself/node,
// this returns '/home/myself/node/wwwroot/static_files/gif/image.gif'

On Windows:

Path::resolve('/foo/bar', './baz');
// Returns: 'G:\\foo\\bar\\baz'

Path::resolve('/foo/bar', '/tmp/file/');
// Returns: 'G:\\tmp\\file'

Path::resolve('wwwroot', 'static_files/png/', '../gif/image.gif');
// If the current working directory is C:\\xampp\\htdocs/,
// this returns 'C:\\xampp\\htdocs\\wwwroot\\static_files\\gif\\image.gif'

Path::rootname($path)

Parameters:

$path string
Return: string

Retrieves the root name of the path. This method extracts the root component of a given path, which can be useful for determining the base directory or starting point for further path manipulations.

For example, on POSIX:

Path::rootname('C:\\xampp\\htdocs\\');
// Returns: ''

Path::rootname('/var/ww/httpdocs');
// Returns: '/'

Path::rootname('C:\\');
// Returns: ''

Path::rootname('G:');
// Returns: ''

Path::rootname('//var/www/httpdocs');
// Returns: '/'

On Windows:

Path::rootname('C:\\xampp\\htdocs\\');
// Returns: 'C:\\'

Path::rootname('/var/ww/httpdocs');
// Returns: '\\'

Path::rootname('C:\\');
// Returns: 'C:\\'

Path::rootname('G:');
// Returns: 'G:'

Path::rootname('//var/www/httpdocs');
// Returns: '\\\\var\\www\\'

Path::sep

For example, on POSIX:

explode(Path::sep, 'foo/bar/baz');
// Returns: ['foo', 'bar', 'baz']

On Windows:

explode(Path::sep, 'foo\\bar\\baz');
// Returns: ['foo', 'bar', 'baz']

On Windows, both the forward slash (/) and backward slash (\) are accepted as path segment separators; however, the Path methods only add backward slashes (\).

Path::tmp($path)

Parameters:

$path string
Return: string

Returns tmp name, To make a tmp name with dirname of given path.

For example, on POSIX:

// Path::tmp suffix random tmp name in given path value.
Path::tmp('foot/bar/baz');
// Returns: 'foot/bar/.!!/.!HyZq'
// Returns: 'foot/bar/.!!/.!XTfs'
// Returns: 'foot/bar/.!!/.!C80D'

On Windows:

// Path::tmp suffix random tmp name in given path value.
Path::tmp('foot\\bar\\baz');
// Returns: 'foot\\bar\\.!!\\.!RBDZ'
// Returns: 'foot\\bar\\.!!\\.!NPia'
// Returns: 'foot\\bar\\.!!\\.!0Kbx'

Path::toNamespacedPath($path)

Parameters:

$path string
Return: string

On Windows systems only, returns an equivalent namespace-prefixed path for the given path. If path is not a string, path will be returned without modifications. This method is meaningful only on Windows system. On POSIX systems, the method is non-operational and always returns path without modifications.

Path::toNamespacedPath('\\foo\\bar/baz\\asdfquux\\abcd\\xyz');
// Returns: '\\\\?\\G:\\foo\\bar\\baz\\asdfquux\\abcd\\xyz'

Path::toNamespacedPath('//foo\\bar/baz\\asdfquux\\abcd\\xyz');
// Returns: '\\\\?\\UNC\\foo\\bar\\baz\\asdfquux\\abcd\\xyz'

Path::UrlToPath($url)

Parameters:

$url string
Return: string

To convert url https://example.com/home/parent/current/path to /home/parent/current/path.

For example, on POSIX:

Path::UrlToPath('https://www.example.com/server/auth/client?id=1');
// Returns: '/server/auth/client'

Path::UrlToPath('https://www.example.com/server/auth/client');
// Returns: '/server/auth/client'

Path::UrlToPath('https://www.example.com/server/auth/client?id=1#root');
// Returns: '/server/auth/client'

On Windows:

Path::UrlToPath('https://www.example.com/server/auth/client?id=1');
// Returns: 'G:\\server\\auth\\client'

Path::UrlToPath('https://www.example.com/server/auth/client');
// Returns: 'G:\\server\\auth\\client'

Path::UrlToPath('https://www.example.com/server/auth/client?id=1#root');
// Returns: 'G:\\server\\auth\\client'

Path::win32

The Path::win32 property provides access to Windows specific implementations of the Path methods.

The API is accessible via Path\Path::win32 or Path\Win32\Win32::class.

Resources

Report issue and send Pull Request in the main Lazervel repository