@drawbridge/drawbridge-utils 0.0.158 → 0.0.160

package/dist/nanoid.d.cts

@@ -11,7 +11,47 @@ import { customAlphabet } from 'nanoid';
 // New code should prefer this subpath, which also exposes `retry`:
 //   const { nanoid, retry } = require( '@drawbridge/drawbridge-utils/nanoid' );
 
-const nanoid = customAlphabet( '0123456789abcdefghijklmnopqrstuvwxyz', 8 );
+const generate = customAlphabet( '0123456789abcdefghijklmnopqrstuvwxyz', 8 );
+
+// SpamAssassin's FROM_LOCAL_NOVOWEL scores any From address whose LOCAL PART
+// carries seven consecutive letters from this class:
+//
+//   header FROM_LOCAL_NOVOWEL  From =~ /[bcdfgjklmnpqrstvwxz]{7}\S*\@/i
+//
+// organization.shortId becomes exactly that: lead mail sends from
+// org+<shortId>@<sending domain> (lib/email.js subAddress). Nineteen of the
+// thirty-six characters in the alphabet above are in the class, so a run of
+// seven inside eight characters is not rare — measured at 1.67% of generated
+// ids, which is roughly one organization in sixty penalised on every lead email
+// it will ever send, decided by nothing but the draw.
+//
+// Rejecting those costs a re-roll on 1.7% of calls and a slice of the keyspace
+// far too small to matter against 36⁸. Applied to EVERY nanoid rather than only
+// the organization's: the rest become slugs in urls where the rule is
+// irrelevant and the cost is nil, and doing it here means no future caller can
+// put an id in an address and quietly reintroduce this.
+//
+// Existing ids are untouched — this only shapes new ones.
+const NOVOWEL = /[bcdfgjklmnpqrstvwxz]{7}/i;
+
+// Bounded rather than looping until clean. At a 1.67% rejection rate the odds
+// of ten consecutive rejections are about 1 in 10^18, so the cap is never
+// reached — but a generator that CANNOT hang is worth more than one that is
+// merely very unlikely to, and returning a slightly penalised id beats spinning.
+const ATTEMPTS = 10;
+
+const nanoid = () => {
+
+	let value = generate();
+
+	for( let attempt = 1; attempt < ATTEMPTS && NOVOWEL.test( value ); attempt++ ){
+
+		value = generate();
+
+	}
+	return value;
+
+};
 
 // Retry an async operation when Mongo rejects an insert because of a
 // duplicate-key error on a specific field. The operation receives a fresh

package/dist/nanoid.d.ts

@@ -11,7 +11,47 @@ import { customAlphabet } from 'nanoid';
 // New code should prefer this subpath, which also exposes `retry`:
 //   const { nanoid, retry } = require( '@drawbridge/drawbridge-utils/nanoid' );
 
-const nanoid = customAlphabet( '0123456789abcdefghijklmnopqrstuvwxyz', 8 );
+const generate = customAlphabet( '0123456789abcdefghijklmnopqrstuvwxyz', 8 );
+
+// SpamAssassin's FROM_LOCAL_NOVOWEL scores any From address whose LOCAL PART
+// carries seven consecutive letters from this class:
+//
+//   header FROM_LOCAL_NOVOWEL  From =~ /[bcdfgjklmnpqrstvwxz]{7}\S*\@/i
+//
+// organization.shortId becomes exactly that: lead mail sends from
+// org+<shortId>@<sending domain> (lib/email.js subAddress). Nineteen of the
+// thirty-six characters in the alphabet above are in the class, so a run of
+// seven inside eight characters is not rare — measured at 1.67% of generated
+// ids, which is roughly one organization in sixty penalised on every lead email
+// it will ever send, decided by nothing but the draw.
+//
+// Rejecting those costs a re-roll on 1.7% of calls and a slice of the keyspace
+// far too small to matter against 36⁸. Applied to EVERY nanoid rather than only
+// the organization's: the rest become slugs in urls where the rule is
+// irrelevant and the cost is nil, and doing it here means no future caller can
+// put an id in an address and quietly reintroduce this.
+//
+// Existing ids are untouched — this only shapes new ones.
+const NOVOWEL = /[bcdfgjklmnpqrstvwxz]{7}/i;
+
+// Bounded rather than looping until clean. At a 1.67% rejection rate the odds
+// of ten consecutive rejections are about 1 in 10^18, so the cap is never
+// reached — but a generator that CANNOT hang is worth more than one that is
+// merely very unlikely to, and returning a slightly penalised id beats spinning.
+const ATTEMPTS = 10;
+
+const nanoid = () => {
+
+	let value = generate();
+
+	for( let attempt = 1; attempt < ATTEMPTS && NOVOWEL.test( value ); attempt++ ){
+
+		value = generate();
+
+	}
+	return value;
+
+};
 
 // Retry an async operation when Mongo rejects an insert because of a
 // duplicate-key error on a specific field. The operation receives a fresh

package/dist/nanoid.js

@@ -1,6 +1,16 @@
 // lib/nanoid.js
 import { customAlphabet } from "nanoid";
-var nanoid = customAlphabet("0123456789abcdefghijklmnopqrstuvwxyz", 8);
+var generate = customAlphabet("0123456789abcdefghijklmnopqrstuvwxyz", 8);
+var NOVOWEL = /[bcdfgjklmnpqrstvwxz]{7}/i;
+var ATTEMPTS = 10;
+var nanoid = () => {
+  let value = generate();
+  for (let attempt = 1; attempt < ATTEMPTS && NOVOWEL.test(value); attempt++) {
+    value = generate();
+  }
+  ;
+  return value;
+};
 var DEFAULT_MAX_RETRIES = 5;
 var retry = async ({
   field,

package/dist/notification.cjs

@@ -0,0 +1,93 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// lib/notification.js
+var notification_exports = {};
+__export(notification_exports, {
+  notificationWarnings: () => notificationWarnings
+});
+module.exports = __toCommonJS(notification_exports);
+var PHRASES = [
+  "act now",
+  "apply now",
+  "click here",
+  "congratulations",
+  "limited time",
+  "no obligation",
+  "once in a lifetime",
+  "risk free",
+  "this is not a scam",
+  "urgent",
+  "you have been selected"
+];
+var SUBJECT_DISPLAY_LIMIT = 60;
+var MESSAGE_SHORT_LIMIT = 20;
+var emojiCount = (value) => (value.match(new RegExp("\\p{Extended_Pictographic}", "gu")) || []).length;
+var shouting = (value) => {
+  const letters = value.replace(/[^A-Za-z]/g, "");
+  if (letters.length < 4) return false;
+  const upper = letters.replace(/[^A-Z]/g, "");
+  return upper.length / letters.length > 0.7;
+};
+var phrasesIn = (value) => {
+  const lower = value.toLowerCase();
+  return PHRASES.filter((phrase) => lower.includes(phrase));
+};
+var list = (values) => values.map((value) => "\u201C" + value + "\u201D").join(", ");
+var subjectWarnings = ({ brand, subject }) => {
+  const value = String(subject || "").trim();
+  if (!value) return [];
+  const found = phrasesIn(value);
+  const emojis = emojiCount(value);
+  return [
+    value.length > SUBJECT_DISPLAY_LIMIT && "Most email apps cut the subject around " + SUBJECT_DISPLAY_LIMIT + " characters \u2014 yours is " + value.length + ".",
+    shouting(value) && "Mostly capitals reads as shouting, and filters treat it that way too.",
+    /[!?]{2,}/.test(value) && "Repeated exclamation or question marks are a common spam signal.",
+    emojis > 1 && "More than one emoji in a subject is a common spam signal.",
+    /[$£€]\s?\d/.test(value) && "A currency amount in the subject is a common spam signal.",
+    found.length > 0 && "Reads like a scam to filters and to people: " + list(found) + ".",
+    brand && !value.toLowerCase().includes(String(brand).toLowerCase()) && "Nothing here says the mail is from " + brand + " \u2014 subjects that name the sender get opened more."
+  ].filter(Boolean);
+};
+var messageWarnings = ({ message }) => {
+  const value = String(message || "").trim();
+  if (!value) return [];
+  const found = phrasesIn(value);
+  return [
+    value.length < MESSAGE_SHORT_LIMIT && "Very short messages read as a fragment, and bulk senders send exactly this shape.",
+    shouting(value) && "Mostly capitals reads as shouting, and filters treat it that way too.",
+    /[!?]{2,}/.test(value) && "Repeated exclamation or question marks are a common spam signal.",
+    found.length > 0 && "Reads like a scam to filters and to people: " + list(found) + "."
+  ].filter(Boolean);
+};
+var notificationWarnings = ({
+  brand,
+  channel = "email",
+  message,
+  subject
+} = {}) => {
+  if (channel !== "email") return { message: [], subject: [] };
+  return {
+    message: messageWarnings({ message }),
+    subject: subjectWarnings({ brand, subject })
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  notificationWarnings
+});

package/dist/notification.d.cts

@@ -0,0 +1,155 @@
+// Warnings about the copy a merchant writes into a notification — the subject
+// and message pair behind every lead-facing send.
+//
+// WHAT THIS IS NOT: a deliverability prediction. Gmail accepts mail and then
+// decides where to file it using reputation and engagement signals no local
+// check can see — a send can score perfectly here and still land in Promotions.
+// Anyone reading a clean result as "this will reach the inbox" has been misled,
+// so nothing here returns a score or a pass. It returns sentences a person can
+// act on, or nothing at all.
+//
+// WHAT IT IS FOR: the own-goals. A merchant swapping one weak default for a
+// worse one, in ALL CAPS, with three exclamation marks. That matters more here
+// than on most platforms because lead mail sends from a SHARED domain
+// (org+<shortId>@send.…), so one merchant's copy is spent out of every other
+// tenant's reputation. A merchant on their own verified domain is spending only
+// their own.
+//
+// Every rule below is a WARNING, never an error. False positives are certain —
+// a giveaway platform's mail legitimately says "you won" — and blocking a
+// merchant's own words over a heuristic is worse than the heuristic is good.
+
+// Deliberately short, and deliberately NOT the usual spam-word list. This
+// product's mail is about prizes: "winner", "free" and "claim" are the domain's
+// own vocabulary and flagging them would fire on every campaign, which teaches
+// people to ignore the warnings entirely. What is left is the scam-SHAPED
+// phrasing — vague, urgent, and naming no brand — which is exactly what a
+// merchant reaches for when they have nothing better to say.
+const PHRASES = [
+	'act now',
+	'apply now',
+	'click here',
+	'congratulations',
+	'limited time',
+	'no obligation',
+	'once in a lifetime',
+	'risk free',
+	'this is not a scam',
+	'urgent',
+	'you have been selected'
+];
+
+// Most clients cut the subject around here, and a mobile list cuts it sooner.
+// Not a spam rule at all — a legibility one — but it belongs in the same place
+// because it is the same question a merchant is asking when they type.
+const SUBJECT_DISPLAY_LIMIT = 60;
+
+// Under this, a body reads as a fragment rather than a message. Short bodies
+// with a link are also the shape bulk senders use, so it is worth a nudge.
+const MESSAGE_SHORT_LIMIT = 20;
+
+const emojiCount = ( value ) => ( value.match( /\p{Extended_Pictographic}/gu ) || [] ).length;
+
+// Shouting is measured over LETTERS, not characters: "WIN A $500 GIFT CARD" is
+// mostly non-letters, and counting those would let a genuinely shouted subject
+// slip under any sensible ratio.
+const shouting = ( value ) => {
+
+	const letters = value.replace( /[^A-Za-z]/g, '' );
+
+	if( letters.length < 4 ) return false;
+
+	const upper = letters.replace( /[^A-Z]/g, '' );
+
+	return ( upper.length / letters.length ) > 0.7;
+
+};
+
+const phrasesIn = ( value ) => {
+
+	const lower = value.toLowerCase();
+
+	return PHRASES.filter( ( phrase ) => lower.includes( phrase ) );
+
+};
+
+const list = ( values ) => values.map( ( value ) => '“' + value + '”' ).join( ', ' );
+
+// `brand` is the organization's own name. A subject that never mentions who is
+// writing is the single most recognisable trait of the mail people delete
+// unread — and the one a merchant can fix in five seconds once it is pointed
+// out. Skipped entirely when no brand is supplied rather than guessed at.
+const subjectWarnings = ({ brand, subject }) => {
+
+	const value = String( subject || '' ).trim();
+
+	if( ! value ) return [];
+
+	const found = phrasesIn( value );
+	const emojis = emojiCount( value );
+
+	return [
+		value.length > SUBJECT_DISPLAY_LIMIT
+			&& 'Most email apps cut the subject around ' + SUBJECT_DISPLAY_LIMIT + ' characters — yours is ' + value.length + '.',
+		shouting( value )
+			&& 'Mostly capitals reads as shouting, and filters treat it that way too.',
+		/[!?]{2,}/.test( value )
+			&& 'Repeated exclamation or question marks are a common spam signal.',
+		emojis > 1
+			&& 'More than one emoji in a subject is a common spam signal.',
+		/[$£€]\s?\d/.test( value )
+			&& 'A currency amount in the subject is a common spam signal.',
+		found.length > 0
+			&& 'Reads like a scam to filters and to people: ' + list( found ) + '.',
+		brand && ! value.toLowerCase().includes( String( brand ).toLowerCase() )
+			&& 'Nothing here says the mail is from ' + brand + ' — subjects that name the sender get opened more.'
+	].filter( Boolean );
+
+};
+
+const messageWarnings = ({ message }) => {
+
+	const value = String( message || '' ).trim();
+
+	if( ! value ) return [];
+
+	const found = phrasesIn( value );
+
+	return [
+		value.length < MESSAGE_SHORT_LIMIT
+			&& 'Very short messages read as a fragment, and bulk senders send exactly this shape.',
+		shouting( value )
+			&& 'Mostly capitals reads as shouting, and filters treat it that way too.',
+		/[!?]{2,}/.test( value )
+			&& 'Repeated exclamation or question marks are a common spam signal.',
+		found.length > 0
+			&& 'Reads like a scam to filters and to people: ' + list( found ) + '.'
+	].filter( Boolean );
+
+};
+
+// ONE ENTRY POINT, answering per field so each warning renders against the
+// input it is about rather than as a pile at the bottom of the form.
+//
+// `channel` is accepted and only 'email' is implemented. SMS is a genuinely
+// different problem — carriers filter on SHAFT categories, link shorteners and
+// opt-out wording, none of which these rules look at — and returning email
+// advice for an SMS would be confidently wrong. It returns nothing instead,
+// until someone writes the carrier rules properly.
+const notificationWarnings = ({
+	brand,
+	channel = 'email',
+	message,
+	subject
+} = {}) => {
+
+	if( channel !== 'email' ) return { message : [], subject : [] };
+
+	return {
+		message : messageWarnings({ message }),
+		subject : subjectWarnings({ brand, subject })
+	};
+
+};
+
+export { notificationWarnings };

package/dist/notification.d.ts

@@ -0,0 +1,155 @@
+// Warnings about the copy a merchant writes into a notification — the subject
+// and message pair behind every lead-facing send.
+//
+// WHAT THIS IS NOT: a deliverability prediction. Gmail accepts mail and then
+// decides where to file it using reputation and engagement signals no local
+// check can see — a send can score perfectly here and still land in Promotions.
+// Anyone reading a clean result as "this will reach the inbox" has been misled,
+// so nothing here returns a score or a pass. It returns sentences a person can
+// act on, or nothing at all.
+//
+// WHAT IT IS FOR: the own-goals. A merchant swapping one weak default for a
+// worse one, in ALL CAPS, with three exclamation marks. That matters more here
+// than on most platforms because lead mail sends from a SHARED domain
+// (org+<shortId>@send.…), so one merchant's copy is spent out of every other
+// tenant's reputation. A merchant on their own verified domain is spending only
+// their own.
+//
+// Every rule below is a WARNING, never an error. False positives are certain —
+// a giveaway platform's mail legitimately says "you won" — and blocking a
+// merchant's own words over a heuristic is worse than the heuristic is good.
+
+// Deliberately short, and deliberately NOT the usual spam-word list. This
+// product's mail is about prizes: "winner", "free" and "claim" are the domain's
+// own vocabulary and flagging them would fire on every campaign, which teaches
+// people to ignore the warnings entirely. What is left is the scam-SHAPED
+// phrasing — vague, urgent, and naming no brand — which is exactly what a
+// merchant reaches for when they have nothing better to say.
+const PHRASES = [
+	'act now',
+	'apply now',
+	'click here',
+	'congratulations',
+	'limited time',
+	'no obligation',
+	'once in a lifetime',
+	'risk free',
+	'this is not a scam',
+	'urgent',
+	'you have been selected'
+];
+
+// Most clients cut the subject around here, and a mobile list cuts it sooner.
+// Not a spam rule at all — a legibility one — but it belongs in the same place
+// because it is the same question a merchant is asking when they type.
+const SUBJECT_DISPLAY_LIMIT = 60;
+
+// Under this, a body reads as a fragment rather than a message. Short bodies
+// with a link are also the shape bulk senders use, so it is worth a nudge.
+const MESSAGE_SHORT_LIMIT = 20;
+
+const emojiCount = ( value ) => ( value.match( /\p{Extended_Pictographic}/gu ) || [] ).length;
+
+// Shouting is measured over LETTERS, not characters: "WIN A $500 GIFT CARD" is
+// mostly non-letters, and counting those would let a genuinely shouted subject
+// slip under any sensible ratio.
+const shouting = ( value ) => {
+
+	const letters = value.replace( /[^A-Za-z]/g, '' );
+
+	if( letters.length < 4 ) return false;
+
+	const upper = letters.replace( /[^A-Z]/g, '' );
+
+	return ( upper.length / letters.length ) > 0.7;
+
+};
+
+const phrasesIn = ( value ) => {
+
+	const lower = value.toLowerCase();
+
+	return PHRASES.filter( ( phrase ) => lower.includes( phrase ) );
+
+};
+
+const list = ( values ) => values.map( ( value ) => '“' + value + '”' ).join( ', ' );
+
+// `brand` is the organization's own name. A subject that never mentions who is
+// writing is the single most recognisable trait of the mail people delete
+// unread — and the one a merchant can fix in five seconds once it is pointed
+// out. Skipped entirely when no brand is supplied rather than guessed at.
+const subjectWarnings = ({ brand, subject }) => {
+
+	const value = String( subject || '' ).trim();
+
+	if( ! value ) return [];
+
+	const found = phrasesIn( value );
+	const emojis = emojiCount( value );
+
+	return [
+		value.length > SUBJECT_DISPLAY_LIMIT
+			&& 'Most email apps cut the subject around ' + SUBJECT_DISPLAY_LIMIT + ' characters — yours is ' + value.length + '.',
+		shouting( value )
+			&& 'Mostly capitals reads as shouting, and filters treat it that way too.',
+		/[!?]{2,}/.test( value )
+			&& 'Repeated exclamation or question marks are a common spam signal.',
+		emojis > 1
+			&& 'More than one emoji in a subject is a common spam signal.',
+		/[$£€]\s?\d/.test( value )
+			&& 'A currency amount in the subject is a common spam signal.',
+		found.length > 0
+			&& 'Reads like a scam to filters and to people: ' + list( found ) + '.',
+		brand && ! value.toLowerCase().includes( String( brand ).toLowerCase() )
+			&& 'Nothing here says the mail is from ' + brand + ' — subjects that name the sender get opened more.'
+	].filter( Boolean );
+
+};
+
+const messageWarnings = ({ message }) => {
+
+	const value = String( message || '' ).trim();
+
+	if( ! value ) return [];
+
+	const found = phrasesIn( value );
+
+	return [
+		value.length < MESSAGE_SHORT_LIMIT
+			&& 'Very short messages read as a fragment, and bulk senders send exactly this shape.',
+		shouting( value )
+			&& 'Mostly capitals reads as shouting, and filters treat it that way too.',
+		/[!?]{2,}/.test( value )
+			&& 'Repeated exclamation or question marks are a common spam signal.',
+		found.length > 0
+			&& 'Reads like a scam to filters and to people: ' + list( found ) + '.'
+	].filter( Boolean );
+
+};
+
+// ONE ENTRY POINT, answering per field so each warning renders against the
+// input it is about rather than as a pile at the bottom of the form.
+//
+// `channel` is accepted and only 'email' is implemented. SMS is a genuinely
+// different problem — carriers filter on SHAFT categories, link shorteners and
+// opt-out wording, none of which these rules look at — and returning email
+// advice for an SMS would be confidently wrong. It returns nothing instead,
+// until someone writes the carrier rules properly.
+const notificationWarnings = ({
+	brand,
+	channel = 'email',
+	message,
+	subject
+} = {}) => {
+
+	if( channel !== 'email' ) return { message : [], subject : [] };
+
+	return {
+		message : messageWarnings({ message }),
+		subject : subjectWarnings({ brand, subject })
+	};
+
+};
+
+export { notificationWarnings };

package/dist/notification.js

@@ -0,0 +1,69 @@
+// lib/notification.js
+var PHRASES = [
+  "act now",
+  "apply now",
+  "click here",
+  "congratulations",
+  "limited time",
+  "no obligation",
+  "once in a lifetime",
+  "risk free",
+  "this is not a scam",
+  "urgent",
+  "you have been selected"
+];
+var SUBJECT_DISPLAY_LIMIT = 60;
+var MESSAGE_SHORT_LIMIT = 20;
+var emojiCount = (value) => (value.match(new RegExp("\\p{Extended_Pictographic}", "gu")) || []).length;
+var shouting = (value) => {
+  const letters = value.replace(/[^A-Za-z]/g, "");
+  if (letters.length < 4) return false;
+  const upper = letters.replace(/[^A-Z]/g, "");
+  return upper.length / letters.length > 0.7;
+};
+var phrasesIn = (value) => {
+  const lower = value.toLowerCase();
+  return PHRASES.filter((phrase) => lower.includes(phrase));
+};
+var list = (values) => values.map((value) => "\u201C" + value + "\u201D").join(", ");
+var subjectWarnings = ({ brand, subject }) => {
+  const value = String(subject || "").trim();
+  if (!value) return [];
+  const found = phrasesIn(value);
+  const emojis = emojiCount(value);
+  return [
+    value.length > SUBJECT_DISPLAY_LIMIT && "Most email apps cut the subject around " + SUBJECT_DISPLAY_LIMIT + " characters \u2014 yours is " + value.length + ".",
+    shouting(value) && "Mostly capitals reads as shouting, and filters treat it that way too.",
+    /[!?]{2,}/.test(value) && "Repeated exclamation or question marks are a common spam signal.",
+    emojis > 1 && "More than one emoji in a subject is a common spam signal.",
+    /[$£€]\s?\d/.test(value) && "A currency amount in the subject is a common spam signal.",
+    found.length > 0 && "Reads like a scam to filters and to people: " + list(found) + ".",
+    brand && !value.toLowerCase().includes(String(brand).toLowerCase()) && "Nothing here says the mail is from " + brand + " \u2014 subjects that name the sender get opened more."
+  ].filter(Boolean);
+};
+var messageWarnings = ({ message }) => {
+  const value = String(message || "").trim();
+  if (!value) return [];
+  const found = phrasesIn(value);
+  return [
+    value.length < MESSAGE_SHORT_LIMIT && "Very short messages read as a fragment, and bulk senders send exactly this shape.",
+    shouting(value) && "Mostly capitals reads as shouting, and filters treat it that way too.",
+    /[!?]{2,}/.test(value) && "Repeated exclamation or question marks are a common spam signal.",
+    found.length > 0 && "Reads like a scam to filters and to people: " + list(found) + "."
+  ].filter(Boolean);
+};
+var notificationWarnings = ({
+  brand,
+  channel = "email",
+  message,
+  subject
+} = {}) => {
+  if (channel !== "email") return { message: [], subject: [] };
+  return {
+    message: messageWarnings({ message }),
+    subject: subjectWarnings({ brand, subject })
+  };
+};
+export {
+  notificationWarnings
+};

package/dist/plans.cjs

@@ -199,7 +199,6 @@ var organization = {
 
 // index.js
 var import_currency_codes = require("currency-codes");
-var import_nanoid = require("nanoid");
 
 // lib/color.js
 var import_tinycolor2 = __toESM(require("tinycolor2"), 1);
@@ -262,8 +261,11 @@ var style = {
   }
 };
 
+// lib/nanoid.js
+var import_nanoid = require("nanoid");
+var generate = (0, import_nanoid.customAlphabet)("0123456789abcdefghijklmnopqrstuvwxyz", 8);
+
 // index.js
-var nanoid = (0, import_nanoid.customAlphabet)("0123456789abcdefghijklmnopqrstuvwxyz", 8);
 var infinite = 1e300;
 var megabyte = 1024 * 1024;
 var gigabyte = megabyte * 1024;

package/dist/plans.d.cts

@@ -1,9 +1,10 @@
 import { organization, page, connection, fields, field } from './features.cjs';
 import { infinite, gigabyte } from './index.cjs';
 import 'currency-codes';
-import 'nanoid';
 import './color.cjs';
 import 'tinycolor2';
+import './nanoid.cjs';
+import 'nanoid';
 import './usage.cjs';
 
 const featuresFor = ( array = [] ) => Object.values({

package/dist/plans.d.ts

@@ -1,9 +1,10 @@
 import { organization, page, connection, fields, field } from './features.js';
 import { infinite, gigabyte } from './index.js';
 import 'currency-codes';
-import 'nanoid';
 import './color.js';
 import 'tinycolor2';
+import './nanoid.js';
+import 'nanoid';
 import './usage.js';
 
 const featuresFor = ( array = [] ) => Object.values({

package/dist/plans.js

@@ -160,7 +160,6 @@ var organization = {
 
 // index.js
 import { code, data } from "currency-codes";
-import { customAlphabet } from "nanoid";
 
 // lib/color.js
 import tinycolor from "tinycolor2";
@@ -223,8 +222,11 @@ var style = {
   }
 };
 
+// lib/nanoid.js
+import { customAlphabet } from "nanoid";
+var generate = customAlphabet("0123456789abcdefghijklmnopqrstuvwxyz", 8);
+
 // index.js
-var nanoid = customAlphabet("0123456789abcdefghijklmnopqrstuvwxyz", 8);
 var infinite = 1e300;
 var megabyte = 1024 * 1024;
 var gigabyte = megabyte * 1024;