@cardstack/boxel-cli 0.3.2-unstable.58 → 0.3.2-unstable.60

package/bundled-test-harness/assets/last-modified-date-test-BzE25NOB.js

@@ -0,0 +1,18 @@
+import { s as __toESM } from "./chunk-CGdGNDIi.js";
+import { n as formatLastSavedText, t as LAST_SAVED_JUST_NOW_THRESHOLD_MS } from "./last-modified-date-EtXqUhdk.js";
+import { t as require_qunit } from "./qunit-Cqwmt9Vl.js";
+//#region tests/unit/last-modified-date-test.ts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+(0, import_qunit.module)("Unit | last-modified-date", function() {
+	(0, import_qunit.test)("treats files from the last minute as just now", function(assert) {
+		let now = Date.UTC(2026, 2, 13, 12, 0, 0);
+		let lastModified = /* @__PURE__ */ new Date(now - (LAST_SAVED_JUST_NOW_THRESHOLD_MS - 1));
+		assert.strictEqual(formatLastSavedText(lastModified, now), "Last saved just now");
+	});
+	(0, import_qunit.test)("switches to relative time after one minute", function(assert) {
+		let now = Date.UTC(2026, 2, 13, 12, 0, 0);
+		let lastModified = new Date(now - LAST_SAVED_JUST_NOW_THRESHOLD_MS);
+		assert.strictEqual(formatLastSavedText(lastModified, now), "Last saved 1 minute ago");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/limited-set-test-NwGNoXKc.js

@@ -0,0 +1,123 @@
+import { s as __toESM } from "./chunk-CGdGNDIi.js";
+import { t as LimitedSet } from "./limited-set-BLZXcdEK.js";
+import { t as require_qunit } from "./qunit-Cqwmt9Vl.js";
+//#region tests/unit/lib/limited-set-test.ts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+(0, import_qunit.module)("Unit | Lib | limited-set", function() {
+	(0, import_qunit.test)("constructor sets the max size correctly", function(assert) {
+		const set = new LimitedSet(5);
+		for (let i = 0; i < 10; i++) set.add(i);
+		assert.strictEqual(set.size, 5, "Set limits size to the max specified");
+	});
+	(0, import_qunit.test)("add() adds items to the set", function(assert) {
+		const set = new LimitedSet(5);
+		set.add("item1");
+		assert.true(set.has("item1"), "Item was added to the set");
+		assert.strictEqual(set.size, 1, "Set size is updated");
+	});
+	(0, import_qunit.test)("add() does not duplicate items", function(assert) {
+		const set = new LimitedSet(5);
+		set.add("item1");
+		set.add("item1");
+		assert.strictEqual(set.size, 1, "Duplicate items are not added");
+	});
+	(0, import_qunit.test)("add() updates the position of existing items", function(assert) {
+		const set = new LimitedSet(3);
+		set.add("item1");
+		set.add("item2");
+		set.add("item3");
+		set.add("item1");
+		set.add("item4");
+		assert.true(set.has("item1"), "item1 was kept (as it was refreshed)");
+		assert.true(set.has("item3"), "item3 was kept");
+		assert.true(set.has("item4"), "item4 was added");
+		assert.false(set.has("item2"), "item2 was removed as the oldest item");
+	});
+	(0, import_qunit.test)("has() returns true for items in the set", function(assert) {
+		const set = new LimitedSet(5);
+		set.add("item1");
+		assert.true(set.has("item1"), "has() returns true for existing items");
+		assert.false(set.has("item2"), "has() returns false for non-existing items");
+	});
+	(0, import_qunit.test)("delete() removes items from the set", function(assert) {
+		const set = new LimitedSet(5);
+		set.add("item1");
+		set.add("item2");
+		assert.true(set.delete("item1"), "delete() returns true when item was deleted");
+		assert.false(set.has("item1"), "Item was removed from the set");
+		assert.strictEqual(set.size, 1, "Set size is updated");
+		assert.false(set.delete("item3"), "delete() returns false when item was not in set");
+	});
+	(0, import_qunit.test)("clear() empties the set", function(assert) {
+		const set = new LimitedSet(5);
+		set.add("item1");
+		set.add("item2");
+		set.clear();
+		assert.strictEqual(set.size, 0, "Set is emptied after clear()");
+		assert.false(set.has("item1"), "Items are removed after clear()");
+	});
+	(0, import_qunit.test)("toArray() returns array of all items", function(assert) {
+		const set = new LimitedSet(5);
+		set.add("item1");
+		set.add("item2");
+		const array = set.toArray();
+		assert.strictEqual(array.length, 2, "Array contains all items");
+		assert.true(array.includes("item1"), "Array contains item1");
+		assert.true(array.includes("item2"), "Array contains item2");
+	});
+	(0, import_qunit.test)("iteration works correctly", function(assert) {
+		const set = new LimitedSet(5);
+		set.add("item1");
+		set.add("item2");
+		const items = [];
+		for (const item of set) items.push(item);
+		assert.strictEqual(items.length, 2, "Iterated over all items");
+		assert.true(items.includes("item1"), "Iteration includes item1");
+		assert.true(items.includes("item2"), "Iteration includes item2");
+	});
+	(0, import_qunit.test)("oldest items are removed when reaching max size", function(assert) {
+		const set = new LimitedSet(3);
+		set.add(1);
+		set.add(2);
+		set.add(3);
+		set.add(4);
+		assert.strictEqual(set.size, 3, "Set size is limited to max size");
+		assert.false(set.has(1), "Oldest item (1) was removed");
+		assert.true(set.has(2), "Newer items are kept");
+		assert.true(set.has(3), "Newer items are kept");
+		assert.true(set.has(4), "Newest item was added");
+	});
+	(0, import_qunit.test)("values() returns an iterator for all values in the set", function(assert) {
+		const set = new LimitedSet(5);
+		set.add("item1");
+		set.add("item2");
+		const values = set.values();
+		const valuesArray = Array.from(values);
+		assert.strictEqual(valuesArray.length, 2, "Values iterator contains all items");
+		assert.true(valuesArray.includes("item1"), "Values iterator contains item1");
+		assert.true(valuesArray.includes("item2"), "Values iterator contains item2");
+	});
+	(0, import_qunit.test)("values() can be used in for-of loops", function(assert) {
+		const set = new LimitedSet(5);
+		set.add("item1");
+		set.add("item2");
+		const items = [];
+		for (const item of set.values()) items.push(item);
+		assert.strictEqual(items.length, 2, "Iterated over all items");
+		assert.true(items.includes("item1"), "Iteration includes item1");
+		assert.true(items.includes("item2"), "Iteration includes item2");
+	});
+	(0, import_qunit.test)("values() correctly reflects updates to the set", function(assert) {
+		const set = new LimitedSet(5);
+		set.add("item1");
+		set.add("item2");
+		set.add("item3");
+		set.delete("item1");
+		const valuesArray = Array.from(set.values());
+		assert.strictEqual(valuesArray.length, 2, "Values iterator shows correct size");
+		assert.false(valuesArray.includes("item1"), "Deleted item is not in values");
+		assert.true(valuesArray.includes("item2"), "Existing item is in values");
+		assert.true(valuesArray.includes("item3"), "New item is in values");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/line-BbGOk93s.js

@@ -0,0 +1,55 @@
+import { i as __name } from "./chunk-CGdGNDIi.js";
+import { n as constant_default, t as withPath } from "./path-Dxiz9G2t.js";
+import { t as array_default } from "./array-CRfHnEm4.js";
+import { rt as linear_default } from "./chunk-5ZQYHXKU-BlVb7vgG.js";
+//#region ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/point.js
+function x(p) {
+	return p[0];
+}
+function y(p) {
+	return p[1];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/line.js
+function line_default(x$1, y$1) {
+	var defined = constant_default(true);
+	var context = null;
+	var curve = linear_default;
+	var output = null;
+	var path = withPath(line);
+	x$1 = typeof x$1 === "function" ? x$1 : x$1 === void 0 ? x : constant_default(x$1);
+	y$1 = typeof y$1 === "function" ? y$1 : y$1 === void 0 ? y : constant_default(y$1);
+	function line(data) {
+		var i;
+		var n = (data = array_default(data)).length;
+		var d;
+		var defined0 = false;
+		var buffer;
+		if (context == null) output = curve(buffer = path());
+		for (i = 0; i <= n; ++i) {
+			if (!(i < n && defined(d = data[i], i, data)) === defined0) if (defined0 = !defined0) output.lineStart();
+			else output.lineEnd();
+			if (defined0) output.point(+x$1(d, i, data), +y$1(d, i, data));
+		}
+		if (buffer) return output = null, buffer + "" || null;
+	}
+	line.x = function(_) {
+		return arguments.length ? (x$1 = typeof _ === "function" ? _ : constant_default(+_), line) : x$1;
+	};
+	line.y = function(_) {
+		return arguments.length ? (y$1 = typeof _ === "function" ? _ : constant_default(+_), line) : y$1;
+	};
+	line.defined = function(_) {
+		return arguments.length ? (defined = typeof _ === "function" ? _ : constant_default(!!_), line) : defined;
+	};
+	line.curve = function(_) {
+		return arguments.length ? (curve = _, context != null && (output = curve(context)), line) : curve;
+	};
+	line.context = function(_) {
+		return arguments.length ? (_ == null ? context = output = null : output = curve(context = _), line) : context;
+	};
+	return line;
+}
+__name(line_default, "default");
+//#endregion
+export { line_default as t };

package/bundled-test-harness/assets/linear-CHTo-YQl.js

@@ -0,0 +1,417 @@
+import { i as __name } from "./chunk-CGdGNDIi.js";
+import { l as color, n as number_default, o as constant_default, r as rgb_default, t as string_default } from "./src-CvuaVSsl.js";
+import { i as exponent_default, n as formatPrefix, r as formatSpecifier, t as format } from "./defaultLocale-CAoL4lzt.js";
+import { t as initRange } from "./init-Bd2YUhsG.js";
+//#region ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/ascending.js
+function ascending(a, b) {
+	return a == null || b == null ? NaN : a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/descending.js
+function descending(a, b) {
+	return a == null || b == null ? NaN : b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/bisector.js
+function bisector(f) {
+	let compare1;
+	let compare2;
+	let delta;
+	if (f.length !== 2) {
+		compare1 = ascending;
+		compare2 = (d, x) => ascending(f(d), x);
+		delta = (d, x) => f(d) - x;
+	} else {
+		compare1 = f === ascending || f === descending ? f : zero;
+		compare2 = f;
+		delta = f;
+	}
+	function left(a, x, lo = 0, hi = a.length) {
+		if (lo < hi) {
+			if (compare1(x, x) !== 0) return hi;
+			do {
+				const mid = lo + hi >>> 1;
+				if (compare2(a[mid], x) < 0) lo = mid + 1;
+				else hi = mid;
+			} while (lo < hi);
+		}
+		return lo;
+	}
+	function right(a, x, lo = 0, hi = a.length) {
+		if (lo < hi) {
+			if (compare1(x, x) !== 0) return hi;
+			do {
+				const mid = lo + hi >>> 1;
+				if (compare2(a[mid], x) <= 0) lo = mid + 1;
+				else hi = mid;
+			} while (lo < hi);
+		}
+		return lo;
+	}
+	function center(a, x, lo = 0, hi = a.length) {
+		const i = left(a, x, lo, hi - 1);
+		return i > lo && delta(a[i - 1], x) > -delta(a[i], x) ? i - 1 : i;
+	}
+	return {
+		left,
+		center,
+		right
+	};
+}
+function zero() {
+	return 0;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/number.js
+function number$1(x) {
+	return x === null ? NaN : +x;
+}
+__name(number$1, "number");
+//#endregion
+//#region ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/bisect.js
+var ascendingBisect = bisector(ascending);
+var bisectRight = ascendingBisect.right;
+ascendingBisect.left;
+bisector(number$1).center;
+//#endregion
+//#region ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/ticks.js
+var e10 = Math.sqrt(50);
+var e5 = Math.sqrt(10);
+var e2 = Math.sqrt(2);
+function tickSpec(start, stop, count) {
+	const step = (stop - start) / Math.max(0, count);
+	const power = Math.floor(Math.log10(step));
+	const error = step / Math.pow(10, power);
+	const factor = error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1;
+	let i1;
+	let i2;
+	let inc;
+	if (power < 0) {
+		inc = Math.pow(10, -power) / factor;
+		i1 = Math.round(start * inc);
+		i2 = Math.round(stop * inc);
+		if (i1 / inc < start) ++i1;
+		if (i2 / inc > stop) --i2;
+		inc = -inc;
+	} else {
+		inc = Math.pow(10, power) * factor;
+		i1 = Math.round(start / inc);
+		i2 = Math.round(stop / inc);
+		if (i1 * inc < start) ++i1;
+		if (i2 * inc > stop) --i2;
+	}
+	if (i2 < i1 && .5 <= count && count < 2) return tickSpec(start, stop, count * 2);
+	return [
+		i1,
+		i2,
+		inc
+	];
+}
+function ticks(start, stop, count) {
+	stop = +stop, start = +start, count = +count;
+	if (!(count > 0)) return [];
+	if (start === stop) return [start];
+	const reverse = stop < start;
+	const [i1, i2, inc] = reverse ? tickSpec(stop, start, count) : tickSpec(start, stop, count);
+	if (!(i2 >= i1)) return [];
+	const n = i2 - i1 + 1;
+	const ticks = new Array(n);
+	if (reverse) if (inc < 0) for (let i = 0; i < n; ++i) ticks[i] = (i2 - i) / -inc;
+	else for (let i = 0; i < n; ++i) ticks[i] = (i2 - i) * inc;
+	else if (inc < 0) for (let i = 0; i < n; ++i) ticks[i] = (i1 + i) / -inc;
+	else for (let i = 0; i < n; ++i) ticks[i] = (i1 + i) * inc;
+	return ticks;
+}
+function tickIncrement(start, stop, count) {
+	stop = +stop, start = +start, count = +count;
+	return tickSpec(start, stop, count)[2];
+}
+function tickStep(start, stop, count) {
+	stop = +stop, start = +start, count = +count;
+	const reverse = stop < start;
+	const inc = reverse ? tickIncrement(stop, start, count) : tickIncrement(start, stop, count);
+	return (reverse ? -1 : 1) * (inc < 0 ? 1 / -inc : inc);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/numberArray.js
+function numberArray_default(a, b) {
+	if (!b) b = [];
+	var n = a ? Math.min(b.length, a.length) : 0;
+	var c = b.slice();
+	var i;
+	return function(t) {
+		for (i = 0; i < n; ++i) c[i] = a[i] * (1 - t) + b[i] * t;
+		return c;
+	};
+}
+__name(numberArray_default, "default");
+function isNumberArray(x) {
+	return ArrayBuffer.isView(x) && !(x instanceof DataView);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/array.js
+function genericArray(a, b) {
+	var nb = b ? b.length : 0;
+	var na = a ? Math.min(nb, a.length) : 0;
+	var x = new Array(na);
+	var c = new Array(nb);
+	var i;
+	for (i = 0; i < na; ++i) x[i] = value_default(a[i], b[i]);
+	for (; i < nb; ++i) c[i] = b[i];
+	return function(t) {
+		for (i = 0; i < na; ++i) c[i] = x[i](t);
+		return c;
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/date.js
+function date_default(a, b) {
+	var d = /* @__PURE__ */ new Date();
+	return a = +a, b = +b, function(t) {
+		return d.setTime(a * (1 - t) + b * t), d;
+	};
+}
+__name(date_default, "default");
+//#endregion
+//#region ../../node_modules/.pnpm/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/object.js
+function object_default(a, b) {
+	var i = {};
+	var c = {};
+	var k;
+	if (a === null || typeof a !== "object") a = {};
+	if (b === null || typeof b !== "object") b = {};
+	for (k in b) if (k in a) i[k] = value_default(a[k], b[k]);
+	else c[k] = b[k];
+	return function(t) {
+		for (k in i) c[k] = i[k](t);
+		return c;
+	};
+}
+__name(object_default, "default");
+//#endregion
+//#region ../../node_modules/.pnpm/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/value.js
+function value_default(a, b) {
+	var t = typeof b;
+	var c;
+	return b == null || t === "boolean" ? constant_default(b) : (t === "number" ? number_default : t === "string" ? (c = color(b)) ? (b = c, rgb_default) : string_default : b instanceof color ? rgb_default : b instanceof Date ? date_default : isNumberArray(b) ? numberArray_default : Array.isArray(b) ? genericArray : typeof b.valueOf !== "function" && typeof b.toString !== "function" || isNaN(b) ? object_default : number_default)(a, b);
+}
+__name(value_default, "default");
+//#endregion
+//#region ../../node_modules/.pnpm/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/round.js
+function round_default(a, b) {
+	return a = +a, b = +b, function(t) {
+		return Math.round(a * (1 - t) + b * t);
+	};
+}
+__name(round_default, "default");
+//#endregion
+//#region ../../node_modules/.pnpm/d3-format@3.1.2/node_modules/d3-format/src/precisionFixed.js
+function precisionFixed_default(step) {
+	return Math.max(0, -exponent_default(Math.abs(step)));
+}
+__name(precisionFixed_default, "default");
+//#endregion
+//#region ../../node_modules/.pnpm/d3-format@3.1.2/node_modules/d3-format/src/precisionPrefix.js
+function precisionPrefix_default(step, value) {
+	return Math.max(0, Math.max(-8, Math.min(8, Math.floor(exponent_default(value) / 3))) * 3 - exponent_default(Math.abs(step)));
+}
+__name(precisionPrefix_default, "default");
+//#endregion
+//#region ../../node_modules/.pnpm/d3-format@3.1.2/node_modules/d3-format/src/precisionRound.js
+function precisionRound_default(step, max) {
+	step = Math.abs(step), max = Math.abs(max) - step;
+	return Math.max(0, exponent_default(max) - exponent_default(step)) + 1;
+}
+__name(precisionRound_default, "default");
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/constant.js
+function constants(x) {
+	return function() {
+		return x;
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/number.js
+function number(x) {
+	return +x;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/continuous.js
+var unit = [0, 1];
+function identity(x) {
+	return x;
+}
+function normalize(a, b) {
+	return (b -= a = +a) ? function(x) {
+		return (x - a) / b;
+	} : constants(isNaN(b) ? NaN : .5);
+}
+function clamper(a, b) {
+	var t;
+	if (a > b) t = a, a = b, b = t;
+	return function(x) {
+		return Math.max(a, Math.min(b, x));
+	};
+}
+function bimap(domain, range, interpolate) {
+	var d0 = domain[0];
+	var d1 = domain[1];
+	var r0 = range[0];
+	var r1 = range[1];
+	if (d1 < d0) d0 = normalize(d1, d0), r0 = interpolate(r1, r0);
+	else d0 = normalize(d0, d1), r0 = interpolate(r0, r1);
+	return function(x) {
+		return r0(d0(x));
+	};
+}
+function polymap(domain, range, interpolate) {
+	var j = Math.min(domain.length, range.length) - 1;
+	var d = new Array(j);
+	var r = new Array(j);
+	var i = -1;
+	if (domain[j] < domain[0]) {
+		domain = domain.slice().reverse();
+		range = range.slice().reverse();
+	}
+	while (++i < j) {
+		d[i] = normalize(domain[i], domain[i + 1]);
+		r[i] = interpolate(range[i], range[i + 1]);
+	}
+	return function(x) {
+		var i = bisectRight(domain, x, 1, j) - 1;
+		return r[i](d[i](x));
+	};
+}
+function copy(source, target) {
+	return target.domain(source.domain()).range(source.range()).interpolate(source.interpolate()).clamp(source.clamp()).unknown(source.unknown());
+}
+function transformer() {
+	var domain = unit;
+	var range = unit;
+	var interpolate = value_default;
+	var transform;
+	var untransform;
+	var unknown;
+	var clamp = identity;
+	var piecewise;
+	var output;
+	var input;
+	function rescale() {
+		var n = Math.min(domain.length, range.length);
+		if (clamp !== identity) clamp = clamper(domain[0], domain[n - 1]);
+		piecewise = n > 2 ? polymap : bimap;
+		output = input = null;
+		return scale;
+	}
+	function scale(x) {
+		return x == null || isNaN(x = +x) ? unknown : (output || (output = piecewise(domain.map(transform), range, interpolate)))(transform(clamp(x)));
+	}
+	scale.invert = function(y) {
+		return clamp(untransform((input || (input = piecewise(range, domain.map(transform), number_default)))(y)));
+	};
+	scale.domain = function(_) {
+		return arguments.length ? (domain = Array.from(_, number), rescale()) : domain.slice();
+	};
+	scale.range = function(_) {
+		return arguments.length ? (range = Array.from(_), rescale()) : range.slice();
+	};
+	scale.rangeRound = function(_) {
+		return range = Array.from(_), interpolate = round_default, rescale();
+	};
+	scale.clamp = function(_) {
+		return arguments.length ? (clamp = _ ? true : identity, rescale()) : clamp !== identity;
+	};
+	scale.interpolate = function(_) {
+		return arguments.length ? (interpolate = _, rescale()) : interpolate;
+	};
+	scale.unknown = function(_) {
+		return arguments.length ? (unknown = _, scale) : unknown;
+	};
+	return function(t, u) {
+		transform = t, untransform = u;
+		return rescale();
+	};
+}
+function continuous() {
+	return transformer()(identity, identity);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/tickFormat.js
+function tickFormat(start, stop, count, specifier) {
+	var step = tickStep(start, stop, count);
+	var precision;
+	specifier = formatSpecifier(specifier == null ? ",f" : specifier);
+	switch (specifier.type) {
+		case "s":
+			var value = Math.max(Math.abs(start), Math.abs(stop));
+			if (specifier.precision == null && !isNaN(precision = precisionPrefix_default(step, value))) specifier.precision = precision;
+			return formatPrefix(specifier, value);
+		case "":
+		case "e":
+		case "g":
+		case "p":
+		case "r":
+			if (specifier.precision == null && !isNaN(precision = precisionRound_default(step, Math.max(Math.abs(start), Math.abs(stop))))) specifier.precision = precision - (specifier.type === "e");
+			break;
+		case "f":
+		case "%":
+			if (specifier.precision == null && !isNaN(precision = precisionFixed_default(step))) specifier.precision = precision - (specifier.type === "%") * 2;
+			break;
+	}
+	return format(specifier);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/linear.js
+function linearish(scale) {
+	var domain = scale.domain;
+	scale.ticks = function(count) {
+		var d = domain();
+		return ticks(d[0], d[d.length - 1], count == null ? 10 : count);
+	};
+	scale.tickFormat = function(count, specifier) {
+		var d = domain();
+		return tickFormat(d[0], d[d.length - 1], count == null ? 10 : count, specifier);
+	};
+	scale.nice = function(count) {
+		if (count == null) count = 10;
+		var d = domain();
+		var i0 = 0;
+		var i1 = d.length - 1;
+		var start = d[i0];
+		var stop = d[i1];
+		var prestep;
+		var step;
+		var maxIter = 10;
+		if (stop < start) {
+			step = start, start = stop, stop = step;
+			step = i0, i0 = i1, i1 = step;
+		}
+		while (maxIter-- > 0) {
+			step = tickIncrement(start, stop, count);
+			if (step === prestep) {
+				d[i0] = start;
+				d[i1] = stop;
+				return domain(d);
+			} else if (step > 0) {
+				start = Math.floor(start / step) * step;
+				stop = Math.ceil(stop / step) * step;
+			} else if (step < 0) {
+				start = Math.ceil(start * step) / step;
+				stop = Math.floor(stop * step) / step;
+			} else break;
+			prestep = step;
+		}
+		return scale;
+	};
+	return scale;
+}
+function linear() {
+	var scale = continuous();
+	scale.copy = function() {
+		return copy(scale, linear());
+	};
+	initRange.apply(scale, arguments);
+	return linearish(scale);
+}
+//#endregion
+export { bisector as a, tickStep as i, continuous as n, copy as r, linear as t };